Kotlin Coroutines: Dispatchers

In Kotlin Coroutines, Dispatchers determine the thread or thread pool on which a coroutine will run. Choosing the right dispatcher ensures optimal performance and responsiveness.

🚦 Built-in Dispatchers

🔹 Dispatchers.Main

Purpose: For UI-bound tasks.

Thread Context: Runs on the main/UI thread.

Available On: Android, JavaFX, Swing (requires a kotlinx-coroutines-android or kotlinx-coroutines-javafx dependency).

Use Cases:

• Updating UI after loading data
• Responding to user events (e.g. clicks)

⚠️ Do not perform blocking or heavy computations here.

🔹 Dispatchers.IO

Purpose: Designed for blocking I/O operations.

Thread Context: A shared pool of threads.

Scalability: Dynamically grows up to ~64 threads by default (more than CPU cores).

Use Cases:

• Reading/writing files
• Network or database calls (JDBC, Retrofit)

✅ Blocking allowed — suitable for legacy APIs.

🔹 Dispatchers.Default

Purpose: For CPU-intensive operations.

Thread Context: Uses a thread pool with number of threads = number of CPU cores.

Use Cases:

• Complex algorithms
• Data crunching, sorting, parsing

🚫 Avoid blocking I/O here — designed for non-blocking compute tasks.

🔹 Dispatchers.Unconfined (less common)

Purpose: Starts coroutine in the current thread but resumes in the thread of the suspending function.

Thread Context: No fixed thread.

Use Cases:

• For debugging or advanced coroutine control
• Lightweight coroutines not bound to any thread

⚠️ Can lead to unexpected behavior; not recommended for UI or production use.

🛠️ Creating a Custom Dispatcher

val myDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()

Use when:

• You want fine-grained control over threading (e.g. limiting concurrency)
• Need a dedicated thread pool for certain tasks

⚠️ Don’t forget to close it after use:

myDispatcher.close()

✅ Choosing the Right Dispatcher – Summary Table

Dispatcher	Ideal For	Backed By	Blocking Allowed?	Scalability
Dispatchers.Main	UI updates, UI event handling	Main/UI thread	❌ No	❌ Low
Dispatchers.IO	File, network, DB I/O	Large shared thread pool	✅ Yes	✅ High
Dispatchers.Default	Calculations, CPU tasks	CPU core thread pool	❌ No	➖ Medium
Dispatchers.Unconfined	Experimental, coroutine chaining	Caller’s thread (initially)	⚠️ Depends	➖ Low

💡 Best Practices

• Use Main only for UI work
• Use IO for anything blocking
• Use Default for heavy logic
• Avoid Unconfined unless you know what you’re doing
• Combine with withContext(dispatcher) to offload work

Related Articles

To learn more about Android development and concurrency:

• Jetpack Compose: Architecture - Understand how to structure your Android app
• Jetpack Compose: Composition Phase - Learn about UI rendering and state management
• Jetpack Compose: Custom Modifiers - Discover how to create reusable UI patterns