Dispatchers.Main, IO, Default behavior in Kotlin - Mini Project: Build & Apply

Using Kotlin Dispatchers: Main, IO, and Default

📖 Scenario: You are building a simple Kotlin program that simulates tasks running on different threads using Dispatchers.Main, Dispatchers.IO, and Dispatchers.Default. This helps you understand how Kotlin manages work on the main thread, background IO tasks, and CPU-intensive tasks.

🎯 Goal: Create a Kotlin program that launches three coroutines, each using a different dispatcher: Main, IO, and Default. Each coroutine prints a message showing which dispatcher it is running on.

📋 What You'll Learn

Create a CoroutineScope using Dispatchers.Main.

Create a variable ioScope using CoroutineScope(Dispatchers.IO).

Create a variable defaultScope using CoroutineScope(Dispatchers.Default).

Launch one coroutine in each scope that prints a message with the dispatcher name.

Print all messages so you can see which dispatcher runs which coroutine.

💡 Why This Matters

🌍 Real World

Understanding dispatchers helps you write Kotlin programs that run tasks on the right threads, improving app responsiveness and performance.

💼 Career

Many Kotlin developers use coroutines and dispatchers daily to manage background work, UI updates, and CPU-heavy tasks efficiently.

1

Set up CoroutineScopes for Main, IO, and Default

Create three variables: mainScope as CoroutineScope(Dispatchers.Main), ioScope as CoroutineScope(Dispatchers.IO), and defaultScope as CoroutineScope(Dispatchers.Default).

Kotlin

// Create CoroutineScopes for Main, IO, and Default dispatchers
// Your code here

Hint

Use CoroutineScope(Dispatchers.Main) to create mainScope. Do the same for ioScope and defaultScope with Dispatchers.IO and Dispatchers.Default.

2

Launch coroutine in mainScope

Use mainScope.launch to start a coroutine that prints "Running on Main dispatcher".

Kotlin

import kotlinx.coroutines.*

val mainScope = CoroutineScope(Dispatchers.Main)
val ioScope = CoroutineScope(Dispatchers.IO)
val defaultScope = CoroutineScope(Dispatchers.Default)

// Launch a coroutine in mainScope that prints the dispatcher message
// Your code here

Hint

Use mainScope.launch { println("Running on Main dispatcher") } to start the coroutine.

3

Launch coroutines in ioScope and defaultScope

Use ioScope.launch to print "Running on IO dispatcher" and defaultScope.launch to print "Running on Default dispatcher".

Kotlin

import kotlinx.coroutines.*

val mainScope = CoroutineScope(Dispatchers.Main)
val ioScope = CoroutineScope(Dispatchers.IO)
val defaultScope = CoroutineScope(Dispatchers.Default)

mainScope.launch {
    println("Running on Main dispatcher")
}

// Launch coroutines in ioScope and defaultScope to print their dispatcher messages
// Your code here

Hint

Use ioScope.launch { println("Running on IO dispatcher") } and defaultScope.launch { println("Running on Default dispatcher") }.

4

Wait for coroutines to finish and print all messages

Add Thread.sleep(500) at the end to allow all coroutines to complete and print their messages.

Kotlin

import kotlinx.coroutines.*

val mainScope = CoroutineScope(Dispatchers.Main)
val ioScope = CoroutineScope(Dispatchers.IO)
val defaultScope = CoroutineScope(Dispatchers.Default)

mainScope.launch {
    println("Running on Main dispatcher")
}
ioScope.launch {
    println("Running on IO dispatcher")
}
defaultScope.launch {
    println("Running on Default dispatcher")
}

// Add a delay to let coroutines finish and print their messages
// Your code here

Hint

Use Thread.sleep(500) to pause the main thread so all coroutines can print their messages.

Practice

1. Which Dispatcher should you use in Kotlin when updating the user interface (UI)?

easy

A. Dispatchers.Main

B. Dispatchers.IO

C. Dispatchers.Default

D. Dispatchers.Unconfined

Solution

1. Step 1: Understand UI thread requirements

   UI updates must happen on the main thread to avoid crashes or freezes.

2. Step 2: Match Dispatcher to UI work

   Dispatchers.Main is designed for UI tasks on the main thread.

3. Final Answer:

   Dispatchers.Main -> Option A

4. Quick Check:

   UI work = Dispatchers.Main [OK]

Hint: UI updates always use Dispatchers.Main [OK]

Common Mistakes:

• Using Dispatchers.IO for UI updates
• Using Dispatchers.Default for UI work
• Confusing Dispatchers.Unconfined with Main

2. Which of the following is the correct way to launch a coroutine on the IO dispatcher in Kotlin?

easy

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

B. CoroutineScope(Dispatchers.Main).launch { /* IO work */ }

C. CoroutineScope(Dispatchers.Default).launch { /* IO work */ }

D. CoroutineScope(Dispatchers.IO).launch { /* IO work */ }

Solution

1. Step 1: Identify correct CoroutineScope usage

   To launch a coroutine on a specific dispatcher, create CoroutineScope with that dispatcher.

2. Step 2: Check syntax correctness

   CoroutineScope(Dispatchers.IO).launch { ... } is correct syntax for IO dispatcher.

3. Final Answer:

   CoroutineScope(Dispatchers.IO).launch { /* IO work */ } -> Option D

4. Quick Check:

   IO dispatcher launch = CoroutineScope(Dispatchers.IO).launch { /* IO work */ } [OK]

Hint: Use CoroutineScope(Dispatchers.IO).launch for IO tasks [OK]

Common Mistakes:

• Using Dispatchers.Main for IO tasks
• Incorrect CoroutineScope.launch syntax
• Using Dispatchers.Default for IO tasks

3. What will be the output of the following Kotlin code snippet?

import kotlinx.coroutines.*

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

medium

A. Running on: DefaultDispatcher-worker-1

B. Running on: main

C. Running on: IO-thread-1

D. Running on: Unconfined

Solution

1. Step 1: Identify the dispatcher used

   The coroutine is launched with Dispatchers.Default, which uses a shared background thread pool.

2. Step 2: Understand thread naming

   Threads in Default dispatcher are named like "DefaultDispatcher-worker-1".

3. Final Answer:

   Running on: DefaultDispatcher-worker-1 -> Option A

4. Quick Check:

   Dispatchers.Default runs on DefaultDispatcher-worker threads [OK]

Hint: Default dispatcher uses background worker threads [OK]

Common Mistakes:

• Assuming it runs on main thread
• Confusing IO thread names with Default
• Expecting Unconfined dispatcher output

4. Consider this Kotlin coroutine code snippet:

CoroutineScope(Dispatchers.Main).launch {
    withContext(Dispatchers.IO) {
        // Perform file read
    }
    println("File read complete")
}

What is the main issue if this code is run in an Android app?

medium

A. Using Dispatchers.Main inside withContext causes a crash

B. File read should be done on Dispatchers.Default, not IO

C. No issue; this is the correct way to switch dispatchers

D. println runs on IO dispatcher causing UI freeze

Solution

1. Step 1: Analyze dispatcher switching

   The code launches on Main dispatcher, then switches to IO for file reading.

2. Step 2: Confirm correct usage

   Switching to Dispatchers.IO for file I/O and back to Main for UI is correct practice.

3. Final Answer:

   No issue; this is the correct way to switch dispatchers -> Option C

4. Quick Check:

   Dispatcher switching Main ↔ IO is correct [OK]

Hint: Switch to IO for I/O, back to Main for UI [OK]

Common Mistakes:

• Thinking Dispatchers.Default is for I/O
• Believing println runs on IO dispatcher
• Assuming dispatcher switch causes crash

5. You want to perform a CPU-intensive calculation without blocking the UI in a Kotlin Android app. Which dispatcher should you use and why?

Select the best option.

hard

A. Dispatchers.Main, because it runs on the main thread

B. Dispatchers.Default, because it is optimized for CPU-heavy work

C. Dispatchers.Unconfined, because it runs immediately

D. Dispatchers.IO, because it handles background tasks

Solution

1. Step 1: Identify task type

   CPU-intensive tasks need background threads to avoid freezing UI.

2. Step 2: Match dispatcher to CPU work

   Dispatchers.Default is designed for CPU-heavy tasks using a shared thread pool.

3. Final Answer:

   Dispatchers.Default, because it is optimized for CPU-heavy work -> Option B

4. Quick Check:

   CPU tasks = Dispatchers.Default [OK]

Hint: Use Default dispatcher for CPU-heavy tasks [OK]

Common Mistakes:

• Using Main dispatcher for CPU work
• Confusing IO dispatcher with CPU dispatcher
• Using Unconfined dispatcher for heavy tasks