Dispatchers and withContext

Why dispatchers?

suspend lets a coroutine pause, but it does not choose a thread. Some work must be on the main thread (updating the UI), and some must stay away from it (reading a big file, compressing an image). A dispatcher is the part of the coroutine system that sends a coroutine to the right thread or pool of threads.

viewModelScope and lifecycleScope start coroutines on Dispatchers.Main by default. That is fine, because suspend calls like Retrofit and Room switch to background threads internally.

A thread pool is a group of threads that are created once and reused for many small jobs, because creating a new thread for every job is slow. IO and Default share threads internally, but IO allows many more threads at once, since most of them are just waiting.

withContext: switch for a block

import kotlinx.coroutines.*
import java.io.File

suspend fun readReport(path: String): String = withContext(Dispatchers.IO) {
    File(path).readText()          // blocking file read, safely off the main thread
}

suspend fun sortedNames(names: List<String>): List<String> = withContext(Dispatchers.Default) {
    names.sorted()                 // CPU work on the Default pool
}

The main-safety rule

Google's guidance: a suspend function should be main-safe, meaning it is safe to call from the main thread. The function itself takes care of moving its blocking work to the right dispatcher with withContext. Then the callers, often ViewModels running on Main, never need to think about threads.

class ReportRepository {
    suspend fun load(): String = withContext(Dispatchers.IO) {
        // blocking work here
        "report data"
    }
}

// In a ViewModel (runs on Main):
// viewModelScope.launch {
//     val text = repository.load()    // main-safe: no thread juggling here
//     _state.value = text
// }

Testing tip: inject dispatchers

Hard-coding Dispatchers.IO inside classes makes tests harder. Many teams pass the dispatcher in through the constructor, with a default value, so tests can swap in a test dispatcher (module 10).

class ImageCompressor(private val cpu: CoroutineDispatcher = Dispatchers.Default) {
    suspend fun compress(bytes: ByteArray): ByteArray = withContext(cpu) {
        bytes.copyOf(bytes.size / 2)     // pretend compression
    }
}

Common mistakes

• Wrapping Retrofit or Room suspend calls in withContext(Dispatchers.IO). Not harmful, but unnecessary: they are already main-safe.
• Doing heavy CPU work on Dispatchers.IO. IO has many threads meant for waiting; CPU work belongs on Default.
• Updating UI from a background dispatcher. Update state on Main (or through StateFlow, which is safe to collect on Main).
• Using GlobalScope.launch(Dispatchers.IO) to "run in the background". Use a structured scope plus withContext.