RunBlocking for bridging in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using runBlocking?

Consider the following Kotlin code snippet using runBlocking. What will be printed when this code runs?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(100)
        println("Inside launch")
    }
    println("Before delay")
    delay(200)
    println("After delay")
}

A Before delay\nAfter delay\nInside launch

B Before delay\nInside launch\nAfter delay

C Inside launch\nBefore delay\nAfter delay

D After delay\nBefore delay\nInside launch

💡 Hint

Remember that runBlocking waits for all child coroutines to complete before finishing.

The runBlocking block waits for all launched coroutines inside it to finish. The launch coroutine delays 100ms before printing. Meanwhile, the main coroutine prints "Before delay", then delays 200ms, allowing the launched coroutine to complete and print "Inside launch" before finally printing "After delay".

❓ Predict Output

intermediate

What error does this Kotlin code produce?

What error will this Kotlin code produce when run?

Kotlin

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        launch {
            delay(100)
            println("Hello")
        }
    }
    println("Done")
}

A No error, prints Hello then Done

B No error, prints Done then Hello

C Compilation error: runBlocking must be called from a coroutine or suspend function

D Runtime error: IllegalStateException

💡 Hint

Check the order of execution inside and outside runBlocking.

The runBlocking block waits for the launch coroutine to complete before exiting. The println("Done") is outside runBlocking and runs after it finishes. Since launch delays 100ms before printing "Hello", the output order is "Hello" then "Done".

🧠 Conceptual

advanced

Why use runBlocking in Kotlin coroutines?

Which of the following best explains why runBlocking is used in Kotlin coroutines?

A To bridge regular blocking code and suspend functions by blocking the current thread until coroutine completes

B To create a coroutine scope that automatically cancels all child coroutines on error

C To launch multiple coroutines concurrently without waiting for their completion

D To start a coroutine that runs asynchronously without blocking the current thread

💡 Hint

Think about how runBlocking helps when calling suspend functions from normal code.

runBlocking is designed to bridge blocking code and suspend functions by blocking the current thread until the coroutine inside completes. This allows calling suspend functions from regular code, such as main(), which is not a suspend function.

🔧 Debug

advanced

Identify the problem in this Kotlin coroutine code using runBlocking

What is the main problem with this Kotlin code snippet?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        delay(1000)
        println("Task done")
    }
    job.cancel()
    println("Cancelled")
}

A The println("Cancelled") is never executed

B The code throws a CancellationException at runtime

C The coroutine is cancelled immediately, so "Task done" is never printed

D The delay inside launch causes a compilation error

💡 Hint

Consider what happens when you cancel a coroutine before it finishes.

The job.cancel() call cancels the launched coroutine immediately before it completes its delay and print. Therefore, "Task done" is never printed. The program prints "Cancelled" and ends normally.

🚀 Application

expert

How many lines are printed by this Kotlin runBlocking code?

How many lines will be printed when running this Kotlin code?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val jobs = List(3) { i ->
        launch {
            delay(100L * i)
            println("Coroutine $i done")
        }
    }
    jobs.forEach { it.join() }
    println("All done")
}

A 3

B 1

C 0

D 4

💡 Hint

Count all printed lines including the final one after all coroutines finish.

There are 3 launched coroutines, each printing "Coroutine 0 done", "Coroutine 1 done", and "Coroutine 2 done" after delays. After all join, the main coroutine prints "All done". So total lines printed are 4.