WithContext for dispatcher switching in Kotlin

Introduction

We use withContext to switch the thread or dispatcher in Kotlin coroutines. It helps run code on the right thread, like doing heavy work in the background and updating UI on the main thread.

When you want to run a slow task without freezing the app screen.

When you need to update the user interface after a background job.

When you want to read or write files without blocking the main thread.

When you want to call a network service and wait for the result safely.

When you want to switch from one thread to another inside a coroutine.

Syntax

Kotlin

suspend fun someFunction() {
    withContext(Dispatchers.IO) {
        // code to run on this dispatcher
    }
}

withContext is a suspend function, so it must be called from a coroutine or another suspend function.

You pass a dispatcher like Dispatchers.IO or Dispatchers.Main to tell where the code should run.

Examples

This runs the code block on a background thread for input/output tasks.

Kotlin

withContext(Dispatchers.IO) {
    // run blocking IO task here
}

This switches back to the main thread to update the user interface.

Kotlin

withContext(Dispatchers.Main) {
    // update UI here
}

This runs CPU-heavy work on a background thread and returns the result.

Kotlin

val result = withContext(Dispatchers.Default) {
    // do CPU heavy work
    42
}

Sample Program

This program starts on the main thread, switches to IO dispatcher to simulate loading data, then switches back to the main thread to print the result.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Start on thread: ${Thread.currentThread().name}")

    val data = withContext(Dispatchers.IO) {
        println("Working on thread: ${Thread.currentThread().name}")
        // Simulate slow IO task
        delay(500)
        "Data loaded"
    }

    println("Back on thread: ${Thread.currentThread().name}")
    println("Result: $data")

    println("End on thread: ${Thread.currentThread().name}")
}

Important Notes

Always use withContext inside a coroutine or suspend function.

Switching dispatchers helps keep your app responsive and avoids freezing the screen.

Common dispatchers are Dispatchers.Main for UI, Dispatchers.IO for input/output, and Dispatchers.Default for CPU work.

Summary

withContext lets you run code on a specific thread or dispatcher inside coroutines.

Use it to keep your app smooth by moving heavy work off the main thread.

Remember to call it only from suspend functions or coroutines.