RunBlocking for bridging in Kotlin - Step-by-Step Execution

Concept Flow - RunBlocking for bridging

Start main thread

↓

Enter runBlocking

↓

Start coroutine inside runBlocking

↓

Coroutine runs and suspends if needed

↓

Coroutine completes

↓

Exit runBlocking

↓

Resume main thread

runBlocking starts a coroutine and blocks the main thread until it finishes, bridging regular and coroutine code.

Execution Sample

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Start")
    delay(1000L)
    println("End")
}

This code runs a coroutine that prints 'Start', waits 1 second, then prints 'End', blocking main thread until done.

Execution Table

Step	Action	Coroutine State	Main Thread State	Output
1	Enter runBlocking	Started	Blocked waiting
2	Print "Start"	Running	Blocked	Start
3	Call delay(1000L)	Suspended (waiting 1s)	Blocked
4	Delay completes	Resumed	Blocked
5	Print "End"	Running	Blocked	End
6	Coroutine completes	Completed	Unblocked
7	Exit runBlocking	N/A	Running

💡 Coroutine finished, runBlocking unblocks main thread and exits.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
Coroutine State	Not started	Running	Suspended	Running	Completed
Main Thread State	Running	Blocked	Blocked	Blocked	Running

Key Moments - 2 Insights

Why does the main thread wait inside runBlocking?

Because runBlocking blocks the main thread until the coroutine inside it completes, as shown in execution_table rows 1 to 6.

What happens during delay inside runBlocking?

The coroutine suspends (row 3), but the main thread stays blocked until the coroutine resumes and finishes (rows 4-6).

Visual Quiz - 3 Questions

Look at the execution_table, what is the coroutine state at Step 3?

A Running

B Completed

C Suspended

D Not started

💡 Hint

Check the 'Coroutine State' column at Step 3 in the execution_table.

At which step does the main thread become unblocked?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look at the 'Main Thread State' column in execution_table rows 5 and 6.

If delay was removed, how would the execution_table change?

A Coroutine would never suspend

B Main thread would block longer

C Output would be delayed

D Coroutine would stay suspended

💡 Hint

Without delay, coroutine runs straight through without suspension (see Step 3 suspension).

Concept Snapshot

runBlocking { ... } runs a coroutine and blocks the current thread until it finishes.
It bridges regular blocking code with coroutines.
Inside runBlocking, coroutine code can suspend (like delay).
Main thread waits until coroutine completes.
Useful for main functions or tests needing coroutine results synchronously.

Full Transcript

runBlocking starts by blocking the main thread and launching a coroutine. The coroutine runs and can suspend, for example during delay. While suspended, the main thread stays blocked. When the coroutine finishes, runBlocking unblocks the main thread and exits. This lets normal blocking code wait for coroutine results safely.