WithContext for dispatcher switching in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine code using withContext?

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

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Start: ${Thread.currentThread().name}")
    withContext(Dispatchers.IO) {
        println("Inside IO: ${Thread.currentThread().name}")
    }
    println("End: ${Thread.currentThread().name}")
}

A

Start: main
Inside IO: DefaultDispatcher-worker-1
End: main

B

Start: main
Inside IO: main
End: main

C

Start: main
Inside IO: IO-thread
End: main

D

Start: main
Inside IO: DefaultDispatcher-worker-1
End: DefaultDispatcher-worker-1

💡 Hint

Remember that withContext(Dispatchers.IO) switches the coroutine context to a background thread pool.

The runBlocking runs on the main thread. The withContext(Dispatchers.IO) block switches to a background thread from the IO dispatcher thread pool, so the thread name changes inside that block. After it finishes, execution returns to the main thread.

❓ Predict Output

intermediate

What happens if you use withContext with the same dispatcher?

What will be the output of this Kotlin coroutine code?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Before withContext: ${Thread.currentThread().name}")
    withContext(Dispatchers.Default) {
        println("Inside withContext: ${Thread.currentThread().name}")
    }
    println("After withContext: ${Thread.currentThread().name}")
}

A

Before withContext: main
Inside withContext: DefaultDispatcher-worker-1
After withContext: main

B

Before withContext: main
Inside withContext: main
After withContext: main

C

Before withContext: DefaultDispatcher-worker-1
Inside withContext: DefaultDispatcher-worker-1
After withContext: DefaultDispatcher-worker-1

D

Before withContext: main
Inside withContext: DefaultDispatcher-worker-1
After withContext: DefaultDispatcher-worker-1

💡 Hint

Think about how runBlocking and withContext interact with dispatchers.

runBlocking runs on the main thread by default. When withContext(Dispatchers.Default) is called, it switches to a background thread from the Default dispatcher thread pool. After the block, execution returns to the main thread.

🔧 Debug

advanced

Identify the error in this withContext usage

What error will this Kotlin code produce when run?

Kotlin

import kotlinx.coroutines.*

fun main() {
    withContext(Dispatchers.IO) {
        println("Running in IO dispatcher")
    }
}

A Unresolved reference: withContext

B IllegalStateException: This job has not been started

C Suspend function 'withContext' should be called only from a coroutine or another suspend function

D No error, prints 'Running in IO dispatcher'

💡 Hint

Check if withContext is called inside a coroutine or suspend function.

withContext is a suspend function and must be called from within a coroutine or another suspend function. Calling it directly in main() without runBlocking or a coroutine scope causes a compiler error.

❓ Predict Output

advanced

What is the output of nested withContext calls with different dispatchers?

Analyze the output of this Kotlin coroutine code with nested withContext calls:

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Start: ${Thread.currentThread().name}")
    withContext(Dispatchers.Default) {
        println("Default: ${Thread.currentThread().name}")
        withContext(Dispatchers.IO) {
            println("IO: ${Thread.currentThread().name}")
        }
        println("Back to Default: ${Thread.currentThread().name}")
    }
    println("End: ${Thread.currentThread().name}")
}

A

Start: main
Default: DefaultDispatcher-worker-1
IO: IO-thread
Back to Default: DefaultDispatcher-worker-1
End: main

B

Start: main
Default: DefaultDispatcher-worker-1
IO: DefaultDispatcher-worker-1
Back to Default: DefaultDispatcher-worker-1
End: main

C

Start: main
Default: main
IO: DefaultDispatcher-worker-1
Back to Default: main
End: main

D

Start: main
Default: DefaultDispatcher-worker-1
IO: DefaultDispatcher-worker-2
Back to Default: DefaultDispatcher-worker-1
End: main

💡 Hint

Each withContext switches to the specified dispatcher thread pool.

The outer withContext(Dispatchers.Default) runs on a Default dispatcher thread. The inner withContext(Dispatchers.IO) switches to a different thread from the IO dispatcher pool. After the inner block, execution returns to the Default dispatcher thread, then finally back to the main thread.

🧠 Conceptual

expert

Why use withContext instead of launch for dispatcher switching?

Which statement best explains why withContext is preferred over launch when switching dispatchers for a block of code?

A <code>launch</code> switches the coroutine context and waits for the block to complete, while <code>withContext</code> starts a new coroutine that runs concurrently.

B <code>withContext</code> switches the coroutine context and waits for the block to complete, preserving sequential execution, while <code>launch</code> starts a new coroutine that runs concurrently.

C <code>withContext</code> creates a new thread, but <code>launch</code> reuses the current thread without switching context.

D <code>launch</code> is used only for UI threads, while <code>withContext</code> is for background threads.

💡 Hint

Think about blocking vs non-blocking behavior and sequential code flow.

withContext is a suspend function that switches the coroutine context and suspends until the block finishes, keeping code sequential. launch starts a new coroutine that runs concurrently and does not wait for completion, so it is not suitable for sequential dispatcher switching.