CoroutineScope and dispatchers in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding CoroutineScope context

What is the default dispatcher used by CoroutineScope when none is specified?

A Dispatchers.Unconfined

B Dispatchers.Default

C Dispatchers.Main

D Dispatchers.IO

💡 Hint

Think about the dispatcher optimized for CPU-intensive work.

When you create a CoroutineScope without specifying a dispatcher, it uses Dispatchers.Default by default, which is optimized for CPU-intensive tasks.

❓ ui_behavior

intermediate

Choosing dispatcher for network calls

Which dispatcher should you use to perform network requests without blocking the main thread?

A Dispatchers.IO

B Dispatchers.Main

C Dispatchers.Default

D Dispatchers.Unconfined

💡 Hint

This dispatcher is optimized for blocking IO tasks like file or network operations.

Dispatchers.IO is designed for offloading blocking IO tasks such as network or disk operations, keeping the main thread free.

❓ lifecycle

advanced

CoroutineScope and Android lifecycle

What happens if you launch a coroutine in a CoroutineScope tied to an Activity and the Activity is destroyed before the coroutine completes?

A The coroutine continues running in the background.

B The coroutine throws an exception immediately.

C The coroutine is automatically cancelled.

D The coroutine switches to Dispatchers.Main automatically.

💡 Hint

Think about how lifecycle-aware scopes behave to prevent memory leaks.

CoroutineScopes tied to lifecycle components like Activities are cancelled automatically when the lifecycle is destroyed, cancelling all running coroutines.

📝 Syntax

advanced

Correct dispatcher usage in coroutine launch

Which of the following code snippets correctly launches a coroutine on the IO dispatcher?

Android Kotlin

fun fetchData() {
  CoroutineScope(Dispatchers.IO).launch {
    // network call
  }
}

A CoroutineScope(Dispatchers.IO).launch { /* network call */ }

B CoroutineScope.launch(Dispatchers.IO) { /* network call */ }

C CoroutineScope(Dispatchers.Main).launch(Dispatchers.IO) { /* network call */ }

D launch(Dispatchers.IO) { /* network call */ }

💡 Hint

Remember how to pass dispatcher to CoroutineScope constructor.

You must pass the dispatcher to CoroutineScope constructor and then call launch without parameters to run on that dispatcher.

🔧 Debug

expert

Diagnosing coroutine dispatcher misuse

Given this code snippet, what error or behavior will occur? fun loadData() { CoroutineScope(Dispatchers.Main).launch { Thread.sleep(3000) println("Data loaded") } }

A The code causes a compile-time error due to Thread.sleep usage.

B The coroutine throws a CancellationException immediately.

C The coroutine runs asynchronously without blocking the UI.

D The UI freezes for 3 seconds because Thread.sleep blocks the main thread.

💡 Hint

Consider what Thread.sleep does on the main thread.

Calling Thread.sleep on Dispatchers.Main blocks the main thread, freezing the UI for the sleep duration.