Coroutine context and dispatchers in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine dispatcher code?

Consider the following Kotlin coroutine code snippet. What will be printed to the console?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        println("Running on: ${Thread.currentThread().name}")
    }.join()
}

A Running on: IO-1

B Running on: DefaultDispatcher-worker-1

C Running on: main

D Running on: CommonPool-worker-1

💡 Hint

Think about which thread the Default dispatcher uses in Kotlin coroutines.

The Dispatchers.Default uses a shared pool of background threads named like DefaultDispatcher-worker-x. The main thread is named 'main', so option B is incorrect. IO dispatcher uses threads named IO-x, and CommonPool is deprecated.

❓ Predict Output

intermediate

What is the value of 'result' after this coroutine context merge?

Given the following Kotlin code, what will be the value of 'result' printed?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val context1 = Dispatchers.Default + CoroutineName("First")
    val context2 = Dispatchers.IO + CoroutineName("Second")
    val mergedContext = context1 + context2
    println("CoroutineName: ${mergedContext[CoroutineName]?.name}")
}

A CoroutineName: Default

B CoroutineName: First

C CoroutineName: null

D CoroutineName: Second

💡 Hint

When merging contexts, the last CoroutineName overrides the previous one.

When two CoroutineName elements are combined, the one from the right side (context2) overrides the left. So the name is 'Second'.

🔧 Debug

advanced

Identify the error in this coroutine dispatcher usage

What error will this Kotlin coroutine code produce when run?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        println("Hello from Main")
    }.join()
}

A java.lang.IllegalStateException: Module with the Main dispatcher is missing.

B No error, prints 'Hello from Main'

C java.lang.NullPointerException

D java.lang.IllegalArgumentException: Dispatcher not found

💡 Hint

Dispatchers.Main requires a special setup in JVM environments.

On JVM without Android or JavaFX, Dispatchers.Main is not available by default and throws IllegalStateException about missing module.

🧠 Conceptual

advanced

Which dispatcher is best for CPU-intensive tasks?

In Kotlin coroutines, which dispatcher is designed to efficiently handle CPU-intensive work?

A Dispatchers.Unconfined

B Dispatchers.IO

C Dispatchers.Default

D Dispatchers.Main

💡 Hint

Think about which dispatcher uses a shared pool of threads optimized for CPU work.

Dispatchers.Default uses a shared pool of threads optimized for CPU-intensive tasks. Dispatchers.IO is for blocking IO tasks. Unconfined starts coroutine in current thread but is not optimized. Main is for UI thread.

❓ Predict Output

expert

What is the output of this nested coroutine context example?

Analyze the following Kotlin code and determine what will be printed to the console.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val outerContext = Dispatchers.Default + CoroutineName("Outer")
    val job = launch(outerContext) {
        println("Outer context: ${coroutineContext[CoroutineName]?.name}")
        withContext(Dispatchers.IO + CoroutineName("Inner")) {
            println("Inner context: ${coroutineContext[CoroutineName]?.name}")
            println("Inner dispatcher: ${coroutineContext[CoroutineDispatcher]}")
        }
        println("Back to outer context: ${coroutineContext[CoroutineName]?.name}")
    }
    job.join()
}

A

Outer context: Outer
Inner context: Inner
Inner dispatcher: Dispatchers.IO
Back to outer context: Outer

B

Outer context: Outer
Inner context: Outer
Inner dispatcher: Dispatchers.Default
Back to outer context: Outer

C

Outer context: Outer
Inner context: Inner
Inner dispatcher: Dispatchers.Default
Back to outer context: Inner

D

Outer context: Outer
Inner context: Inner
Inner dispatcher: Dispatchers.IO
Back to outer context: Inner

💡 Hint

withContext changes both dispatcher and CoroutineName temporarily inside the block.

Inside withContext, the coroutine context is replaced with Dispatchers.IO and CoroutineName("Inner"). After withContext block, the context reverts to the outer one.