Coroutine context and dispatchers in Kotlin - Step-by-Step Execution

Concept Flow - Coroutine context and dispatchers

Start Coroutine

↓

CoroutineContext Created

↓

Dispatcher Selected

↓

Coroutine Runs on Dispatcher

↓

Coroutine Suspends or Resumes

↓

Coroutine Completes

↓

End

This flow shows how a coroutine starts with a context, selects a dispatcher to decide the thread, runs, suspends or resumes, and finally completes.

Execution Sample

Kotlin

import kotlinx.coroutines.*

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

This code launches a coroutine on the Default dispatcher and prints the thread name it runs on.

Execution Table

Step	Action	CoroutineContext	Dispatcher	Thread	Output
1	runBlocking starts main coroutine	Empty + runBlocking context	Main dispatcher	main
2	launch coroutine with Dispatchers.Default	runBlocking + Dispatchers.Default	Default dispatcher	DefaultDispatcher-worker-1
3	Coroutine runs on Default dispatcher thread	runBlocking + Dispatchers.Default	Default dispatcher	DefaultDispatcher-worker-1	Running on thread: DefaultDispatcher-worker-1
4	Coroutine completes	runBlocking + Dispatchers.Default	Default dispatcher	DefaultDispatcher-worker-1
5	runBlocking completes	Empty	Main dispatcher	main

💡 All coroutines complete and runBlocking ends, program finishes.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
CoroutineContext	Empty	runBlocking + Dispatchers.Default	runBlocking + Dispatchers.Default	Empty
Dispatcher	Main dispatcher	Default dispatcher	Default dispatcher	Main dispatcher
Thread	main	DefaultDispatcher-worker-1	DefaultDispatcher-worker-1	main

Key Moments - 3 Insights

Why does the coroutine run on a different thread than the main thread?

Because the coroutine was launched with Dispatchers.Default (see execution_table step 2), it uses a background thread from the Default dispatcher thread pool, not the main thread.

What is the role of CoroutineContext here?

CoroutineContext holds information like the dispatcher and job. It decides where and how the coroutine runs (see execution_table steps 2 and 3).

Why does runBlocking use the main thread while launch uses Default dispatcher?

runBlocking blocks the main thread to wait for coroutines, so it uses the main dispatcher. launch explicitly uses Dispatchers.Default, so it runs on a background thread (see execution_table steps 1 and 2).

Visual Quiz - 3 Questions

Look at the execution_table, on which thread does the coroutine launched with Dispatchers.Default run?

A IO-thread-1

B main

C DefaultDispatcher-worker-1

D Unconfined

💡 Hint

Check the 'Thread' column at step 3 in the execution_table.

At which step does the coroutine print its running thread?

A Step 3

B Step 2

C Step 1

D Step 5

💡 Hint

Look at the 'Output' column in the execution_table.

If we change launch to use Dispatchers.IO, what changes in the execution_table?

A No change, still Default dispatcher and thread

B Dispatcher and Thread columns at step 2 and 3 change to IO dispatcher and IO thread

C runBlocking uses IO dispatcher

D Output changes to 'Running on thread: main'

💡 Hint

Dispatcher and Thread columns reflect the dispatcher used in launch (see steps 2 and 3).

Concept Snapshot

Coroutine context holds info like dispatcher and job.
Dispatcher decides which thread runs the coroutine.
Common dispatchers: Main, Default, IO, Unconfined.
launch(Dispatchers.Default) runs on background thread.
runBlocking blocks main thread until done.
Context + dispatcher control coroutine execution.

Full Transcript

This visual trace shows how Kotlin coroutines use context and dispatchers to decide where they run. The main coroutine starts with runBlocking on the main thread. A child coroutine is launched with Dispatchers.Default, so it runs on a background thread named DefaultDispatcher-worker-1. The coroutine prints its thread name, then completes. Finally, runBlocking ends and the program finishes. The coroutine context holds the dispatcher info, which controls the thread used. Changing the dispatcher changes the thread. This helps run coroutines efficiently on different threads.