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.

Practice

1. What is the main purpose of runBlocking in Kotlin coroutines?

easy

A. To create a new thread for running coroutines

B. To launch a coroutine without blocking the current thread

C. To cancel running coroutines immediately

D. To bridge blocking code and coroutine code by blocking the current thread until coroutine completes

Solution

1. Step 1: Understand the role of runBlocking

   runBlocking is designed to bridge blocking and coroutine code by blocking the current thread until the coroutine inside it finishes.

2. Step 2: Compare with other coroutine builders

   Unlike launch or async, runBlocking blocks the thread, making it suitable for main functions or tests but not for UI or performance-critical code.

3. Final Answer:

   To bridge blocking code and coroutine code by blocking the current thread until coroutine completes -> Option D

4. Quick Check:

   runBlocking blocks thread until coroutine finishes = C [OK]

Hint: runBlocking blocks thread until coroutine finishes [OK]

Common Mistakes:

• Thinking runBlocking launches coroutine without blocking
• Confusing runBlocking with launch or async
• Assuming runBlocking creates a new thread

2. Which of the following is the correct syntax to use runBlocking in Kotlin?

easy

A. runBlocking[ println("Hello") ]

B. runBlocking() -> println("Hello")

C. runBlocking { println("Hello") }

D. runBlocking => { println("Hello") }

Solution

1. Step 1: Recall runBlocking syntax

   runBlocking is a function that takes a lambda block inside curly braces to run coroutine code.

2. Step 2: Identify correct syntax

   runBlocking { println("Hello") } uses curly braces correctly with a lambda block. Other options use invalid syntax like parentheses with arrow or square brackets.

3. Final Answer:

   runBlocking { println("Hello") } -> Option C

4. Quick Check:

   runBlocking uses curly braces for lambda = A [OK]

Hint: runBlocking uses curly braces for coroutine block [OK]

Common Mistakes:

• Using parentheses instead of curly braces
• Using arrow or square brackets incorrectly
• Missing lambda block inside runBlocking

3. What will be the output of the following Kotlin code?

import kotlinx.coroutines.*
fun main() = runBlocking {
    launch {
        delay(100)
        println("World")
    }
    println("Hello")
}

medium

A. Hello\nWorld

B. World\nHello

C. Hello

D. World

Solution

1. Step 1: Understand runBlocking and launch behavior

   runBlocking blocks the main thread until all coroutines inside complete. The launch coroutine delays 100ms before printing "World".

2. Step 2: Trace the print statements

   "Hello" is printed immediately in runBlocking, then after 100ms delay, "World" is printed by the launched coroutine.

3. Final Answer:

   Hello World -> Option A

4. Quick Check:

   runBlocking waits; launch delays; prints Hello then World = D [OK]

Hint: runBlocking waits; launch delays; prints Hello then World [OK]

Common Mistakes:

• Assuming launch runs immediately before println("Hello")
• Ignoring delay effect
• Thinking runBlocking does not wait for launch

4. Identify the error in this Kotlin code using runBlocking:

fun main() {
    runBlocking {
        delay(1000)
        println("Done")
    }
}

medium

A. runBlocking cannot be used inside main function

B. Missing import for delay function

C. delay cannot be called inside runBlocking

D. println should be outside runBlocking

Solution

1. Step 1: Check for necessary imports

   The delay function is part of kotlinx.coroutines package and requires import kotlinx.coroutines.delay.

2. Step 2: Verify usage of runBlocking and delay

   runBlocking can be used inside main, and delay is allowed inside runBlocking coroutine scope, so no error there.

3. Final Answer:

   Missing import for delay function -> Option B

4. Quick Check:

   delay needs import kotlinx.coroutines.delay = A [OK]

Hint: Import kotlinx.coroutines.delay to use delay inside runBlocking [OK]

Common Mistakes:

• Thinking runBlocking can't be used in main
• Assuming delay is a blocking call
• Placing println outside runBlocking unnecessarily

5. You want to write a Kotlin main function that prints numbers 1 to 3 with a 500ms delay between each, using runBlocking. Which code correctly achieves this?

hard

A. fun main() = runBlocking {
for (i in 1..3) {
delay(500)
println(i)
}
}

B. fun main() {
for (i in 1..3) {
delay(500)
println(i)
}
}

C. fun main() = runBlocking {
(1..3).forEach {
launch { delay(500); println(it) }
}
}

D. fun main() {
(1..3).forEach {
Thread.sleep(500)
println(it)
}
}

Solution

1. Step 1: Understand runBlocking usage for sequential delay

   fun main() = runBlocking { for (i in 1..3) { delay(500) println(i) } } uses runBlocking once and delays inside a for loop, printing numbers sequentially with 500ms delay.

2. Step 2: Analyze other options

   fun main() { for (i in 1..3) { delay(500) println(i) } } lacks a coroutine scope, so delay() will not compile. fun main() = runBlocking { (1..3).forEach { launch { delay(500); println(it) } } } launches coroutines concurrently, printing numbers out of order. fun main() { (1..3).forEach { Thread.sleep(500) println(it) } } uses Thread.sleep, which blocks thread but not coroutine style.

3. Final Answer:

   fun main() = runBlocking { for (i in 1..3) { delay(500) println(i) } } -> Option A

4. Quick Check:

   runBlocking with sequential delay in loop = B [OK]

Hint: Use runBlocking once with delay inside loop for sequential prints [OK]

Common Mistakes:

• Using runBlocking inside loop repeatedly
• Launching coroutines without waiting
• Using Thread.sleep instead of delay in coroutines