Launch coroutine builder in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine launch code?

Consider this Kotlin code using launch to start a coroutine. What will it print?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(100L)
        println("World!")
    }
    println("Hello,")
}

A Hello,\nWorld!

B World!\nHello,

C Hello,

D World!

💡 Hint

Remember that launch starts a new coroutine concurrently, and runBlocking waits for all child coroutines.

The launch coroutine starts and delays for 100ms before printing "World!". Meanwhile, the main coroutine prints "Hello," immediately. Because runBlocking waits for the launched coroutine to finish, both lines print in order: "Hello," then "World!".

🧠 Conceptual

intermediate

Which statement about launch coroutine builder is true?

Choose the correct statement about the launch coroutine builder in Kotlin.

A <code>launch</code> returns a <code>Deferred</code> and blocks until the coroutine completes.

B <code>launch</code> returns a <code>Job</code> and does not block the current thread.

C <code>launch</code> always blocks the current thread until completion.

D <code>launch</code> returns the result of the coroutine directly.

💡 Hint

Think about what launch returns and how it behaves with threads.

launch starts a coroutine and immediately returns a Job object. It does not block the current thread. The coroutine runs concurrently until it completes or is cancelled.

🔧 Debug

advanced

What error does this coroutine launch code produce?

Examine this Kotlin code snippet. What error will it raise when run?

Kotlin

import kotlinx.coroutines.*

fun main() {
    launch {
        println("Hello from coroutine")
    }
}

A Compilation error: missing suspend modifier

B IllegalStateException at runtime

C Unresolved reference: launch

D No error, prints "Hello from coroutine"

💡 Hint

Consider where launch can be called and what context is required.

The launch coroutine builder must be called from a coroutine scope or suspend function. Calling it directly in main without a scope causes a compilation error: "Unresolved reference: launch".

📝 Syntax

advanced

Which option correctly launches a coroutine that prints "Done"?

Choose the correct Kotlin code snippet that launches a coroutine to print "Done" inside runBlocking.

A

runBlocking {
    launch
    println("Done")
}

B

runBlocking {
    launch() {
        println("Done")
    }
}

C

runBlocking {
    launch
    {
        println("Done")
    }
}

D

runBlocking {
    launch {
        println("Done")
    }
}

💡 Hint

Check the syntax of launch and its lambda parameter.

Option D correctly calls launch with a lambda block inside runBlocking. Options B and C have syntax errors due to misplaced parentheses or braces. Option D misses the lambda block for launch.

🚀 Application

expert

How many coroutines run concurrently in this code?

Given this Kotlin code, how many coroutines run concurrently?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    repeat(3) {
        launch {
            delay(100L * it)
            println("Coroutine $it done")
        }
    }
}

A 3 coroutines run concurrently

B Only 1 coroutine runs at a time sequentially

C 2 coroutines run concurrently

D No coroutines run concurrently

💡 Hint

Think about how launch and repeat work inside runBlocking.

The repeat(3) launches 3 separate coroutines concurrently. Each coroutine delays for a different time but all run concurrently inside runBlocking.