RunBlocking for bridging in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a coroutine that blocks the current thread until it completes.

Kotlin

import kotlinx.coroutines.*

fun main() {
    [1] {
        println("Hello from coroutine!")
    }
}

Drag options to blanks, or click blank then click option'

Alaunch

Basync

CrunBlocking

Ddelay

Attempts:

3 left

💡 Hint

Common Mistakes

Using launch which is non-blocking and returns immediately.

Using async without awaiting the result.

runBlocking starts a coroutine and blocks the current thread until it finishes. This is useful for bridging regular blocking code with coroutines.

2fill in blank

medium

Complete the code to delay inside a runBlocking coroutine.

Kotlin

import kotlinx.coroutines.*

fun main() = [1] {
    println("Start")
    delay(500)
    println("End")
}

Drag options to blanks, or click blank then click option'

ArunBlocking

Basync

Claunch

DwithContext

Attempts:

3 left

💡 Hint

Common Mistakes

Using launch which does not block the main thread.

Trying to call delay outside a coroutine scope.

runBlocking is used here to create a coroutine scope that blocks the main thread, allowing delay to suspend inside it.

3fill in blank

hard

Fix the error in the code by choosing the correct coroutine builder to bridge blocking and suspending code.

Kotlin

import kotlinx.coroutines.*

fun main() {
    [1] {
        val result = async {
            delay(100)
            "Done"
        }.await()
        println(result)
    }
}

Drag options to blanks, or click blank then click option'

Alaunch

BrunBlocking

CGlobalScope.launch

DcoroutineScope

Attempts:

3 left

💡 Hint

Common Mistakes

Using launch which returns immediately and does not block.

Using GlobalScope.launch which is also non-blocking.

runBlocking is needed here to block the main thread until the coroutine completes and the result is printed.

4fill in blank

hard

Fill both blanks to create a map of word lengths for words longer than 3 characters inside runBlocking.

Kotlin

import kotlinx.coroutines.*

fun main() = [1] {
    val words = listOf("apple", "bat", "carrot", "dog")
    val lengths = words.filter { word -> word.length > 3 }.associate { word -> word to [2] }
    println(lengths)
}

Drag options to blanks, or click blank then click option'

ArunBlocking

Bword.length

Cword.uppercase()

Dlaunch

Attempts:

3 left

💡 Hint

Common Mistakes

Using launch which does not block the main thread.

Using word.uppercase() instead of length.

runBlocking creates the coroutine scope that blocks the main thread. The map comprehension uses word.length to get the length of each word.

5fill in blank

hard

Fill all three blanks to create a filtered map of uppercase words and their lengths inside runBlocking.

Kotlin

import kotlinx.coroutines.*

fun main() = [1] {
    val words = listOf("apple", "bat", "carrot", "dog")
    val filtered = words.filter { word -> word.length > 3 }.associate { word -> word.[2]() to word.[3] }
    println(filtered)
}

Drag options to blanks, or click blank then click option'

ArunBlocking

Buppercase

Clength

Dlowercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase instead of uppercase.

Using launch instead of runBlocking.

runBlocking blocks the main thread. word.uppercase() converts words to uppercase keys, and length gets their lengths as values.

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