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.

Practice

1. What does the launch coroutine builder do in Kotlin?

easy

A. Starts a new coroutine that runs independently without blocking the current thread.

B. Blocks the current thread until the coroutine completes.

C. Returns a value from the coroutine immediately.

D. Creates a new thread for each coroutine.

Solution

1. Step 1: Understand the purpose of launch

   The launch builder starts a coroutine that runs concurrently without blocking the current thread.

2. Step 2: Compare with other coroutine builders

   Unlike async, launch does not return a result and does not block the thread.

3. Final Answer:

   Starts a new coroutine that runs independently without blocking the current thread. -> Option A

4. Quick Check:

   launch = independent coroutine start [OK]

Hint: Remember: launch starts, doesn't block or return value [OK]

Common Mistakes:

• Thinking launch blocks the thread
• Expecting launch to return a value
• Confusing launch with thread creation

2. Which of the following is the correct syntax to launch a coroutine in Kotlin?

easy

A. launch: { println("Hello") }

B. launch { println("Hello") }

C. launch -> println("Hello")

D. launch() println("Hello")

Solution

1. Step 1: Recall the syntax of launch

   The launch builder requires a lambda block enclosed in curly braces.

2. Step 2: Check each option

   launch { println("Hello") } correctly uses launch { ... }. Others have syntax errors or wrong symbols.

3. Final Answer:

   launch { println("Hello") } -> Option B

4. Quick Check:

   Correct coroutine launch syntax = launch { println("Hello") } [OK]

Hint: Use curly braces {} after launch for the coroutine block [OK]

Common Mistakes:

• Omitting curly braces
• Using parentheses without braces
• Using arrow or colon incorrectly

3. What will be the output of this Kotlin code snippet?

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

medium

A. World\nHello

B. Hello

C. Hello\nWorld

D. World

Solution

1. Step 1: Analyze the order of execution

   The launch coroutine delays 100ms before printing "World". Meanwhile, println("Hello") runs immediately.

2. Step 2: Understand runBlocking behavior

   runBlocking waits for all child coroutines to complete before exiting, so both prints occur.

3. Final Answer:

   Hello World -> Option C

4. Quick Check:

   Immediate print then delayed print = Hello\nWorld [OK]

Hint: Immediate prints appear before delayed ones in launch [OK]

Common Mistakes:

• Assuming launch blocks main thread
• Expecting 'World' before 'Hello'
• Ignoring delay effect

4. Identify the error in this Kotlin coroutine code:

fun main() = runBlocking {
    launch {
        delay(100)
        println("Done")
    }
    cancel()
    println("Cancelled")
}

medium

A. println("Cancelled") should be inside launch.

B. delay() cannot be used inside launch.

C. launch must return a value.

D. Calling cancel() cancels the runBlocking scope immediately, so "Done" is never printed.

Solution

1. Step 1: Understand cancel() effect on runBlocking

   Calling cancel() cancels the entire coroutine scope immediately, stopping child coroutines.

2. Step 2: Check output consequences

   Because of cancellation, the launched coroutine does not complete, so "Done" is not printed, but "Cancelled" is printed after cancel.

3. Final Answer:

   Calling cancel() cancels the runBlocking scope immediately, so "Done" is never printed. -> Option D

4. Quick Check:

   cancel() stops coroutines immediately = Calling cancel() cancels the runBlocking scope immediately, so "Done" is never printed. [OK]

Hint: cancel() stops all coroutines in the scope immediately [OK]

Common Mistakes:

• Thinking delay() is invalid in launch
• Expecting launch to return a value
• Assuming println after cancel won't run

5. You want to launch multiple coroutines that print numbers 1 to 3 with a delay, but ensure the main program waits for all to finish. Which code correctly achieves this?

hard

A. runBlocking {
repeat(3) { i ->
launch {
delay(100L * i)
println(i + 1)
}
}
}

B. runBlocking {
repeat(3) { i ->
launch {
delay(100L * i)
println(i + 1)
}
}
println("Done")
}

C. repeat(3) { i ->
launch {
delay(100L * i)
println(i + 1)
}
}
println("Done")

D. runBlocking {
repeat(3) { i ->
launch {
delay(100L * i)
println(i + 1)
}
}
delay(400)
}

Solution

1. Step 1: Ensure main waits for coroutines

   Using runBlocking with launch inside ensures the main thread waits for all launched coroutines to complete.

2. Step 2: Check each option's behavior

   runBlocking { repeat(3) { i -> launch { delay(100L * i) println(i + 1) } } } launches coroutines inside runBlocking, so main waits. runBlocking { repeat(3) { i -> launch { delay(100L * i) println(i + 1) } } println("Done") } prints "Done" immediately without waiting. repeat(3) { i -> launch { delay(100L * i) println(i + 1) } } println("Done") launches outside runBlocking, so main exits early. runBlocking { repeat(3) { i -> launch { delay(100L * i) println(i + 1) } } delay(400) } uses delay but is less reliable than waiting for coroutines.

3. Final Answer:

   runBlocking with launch inside to wait for all coroutines. -> Option A

4. Quick Check:

   runBlocking + launch inside = wait for all [OK]

Hint: Use runBlocking to wait for all launched coroutines [OK]

Common Mistakes:

• Launching coroutines outside runBlocking
• Printing before coroutines finish
• Using delay to wait instead of structured concurrency