Kotlin : 100 Interview Questions and Answers PART6

26. What Are Coroutines in Kotlin?

Coroutines in Kotlin are a modern and lightweight way to write asynchronous and non-blocking code. They simplify tasks like network requests, file I/O, or delayed operations — without blocking threads.

Simple Definition

A coroutine is a piece of code that can suspend its execution and resume later — allowing you to write sequential-looking code that executes asynchronously under the hood.

Why Use Coroutines?

• -Efficiently handle long-running operations without blocking threads
• -Replace callbacks, RxJava, or Threads
• -Makes asynchronous code easier to read and maintain
• -Great for concurrency and parallelism

Key Concepts:

Example: Basic Coroutine

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000) // Non-blocking delay
        println("Hello from coroutine!")
    }
    println("Main thread continues...")
}

Output:

Main thread continues...
Hello from coroutine!

Real-Life Use Cases

• - Networking (Retrofit + Coroutine)
• - File I/O
• - UI delay and animations
• - Database queries (e.g., Room)
• - Concurrent tasks (e.g., API calls in parallel)

27. Comparison with Threads and Coroutine

28. Explain Suspend modifier.

In Kotlin, the suspend modifier is used to mark a function as suspendable — meaning it can be paused and resumed at a later point without blocking a thread.

Definition

A suspend function is a special kind of function that can suspend its execution to wait for a result and resume later without blocking the calling thread.

Key Points

• - suspend can only be called from:
  •    - another suspend function
  •    - a coroutine scope (like launch, async, or runBlocking)
• - It's used to perform long-running operations like: 
  •   - network calls
  •   - file access
  •   - database operations
• - Doesn't block the thread; instead, it suspends and lets other coroutines run.

Example:

suspend fun fetchData(): String {
    delay(1000) // Suspends the coroutine, doesn't block thread
    return "Data fetched!"
}

fun main() = runBlocking {
    val result = fetchData()
    println(result)
}

delay() is a suspend function — it pauses the coroutine for 1 second without blocking the thread.

Suspend ≠ Asynchronous Automatically

• - suspend does not mean the function runs on a background thread by default.
• - It must be called from the proper coroutine context (like Dispatchers.IO, Dispatchers.Default).

suspend fun doHeavyWork() {
    withContext(Dispatchers.IO) {
        // Run in IO thread
    }
}

You Cannot Call suspend From Regular Code

fun normalFunction() {
    fetchData() // ❌ Error: suspend function can't be called from here
}

Benefits

• - Clean, readable asynchronous code
• - No nested callbacks
• - Thread-efficient
• - Supports structured concurrency

29. What Is CoroutineScope in Kotlin?

In Kotlin, CoroutineScope defines a scope for coroutines — controlling how long coroutines run and when they should be cancelled. It's essential for managing coroutine lifecycle safely and predictably.

Simple Definition

A CoroutineScope provides the context in which coroutines run — including the Job, Dispatcher, and lifecycle boundaries.

Core Components of a CoroutineScope

• - Dispatcher (Dispatchers.IO, Dispatchers.Main, etc.): Defines the thread(s) used.
• - Job: Handles the coroutine's lifecycle and cancellation.
• - Context: Combination of Job + Dispatcher and others.

Example:

class MyActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        launch {
            val result = fetchData()
            println(result)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        cancel() // Cancel all coroutines in this scope
    }
}

In this example:

• - CoroutineScope is tied to the activity.
• - launch {} runs the coroutine in the scope.
• - cancel() ensures coroutines are stopped when the activity is destroyed.

Creating a Scope Manually

val scope = CoroutineScope(Dispatchers.IO + Job())

scope.launch {
    // Background work here
}

You can also use built-in scopes like:

• - GlobalScope — not recommended for structured concurrency
• - MainScope() — good for Android lifecycle-aware components
• - lifecycleScope — available in AndroidX
• - rememberCoroutineScope() — for Compose

Why Not Use GlobalScope?

GlobalScope.launch creates coroutines that live forever unless manually cancelled — which can lead to memory leaks or unexpected behavior.

Best Practices

30. What are the benefits of using coroutines in kotlin ?