Launch coroutine builder in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the launch coroutine builder in Kotlin?

The launch coroutine builder starts a new coroutine without blocking the current thread. It runs concurrently and returns a Job that can be used to manage the coroutine's lifecycle.

intermediate

How does launch differ from async in Kotlin coroutines?

launch starts a coroutine that does not return a result and returns a Job. async starts a coroutine that returns a result wrapped in a Deferred, which can be awaited.

beginner

What does the Job returned by launch allow you to do?

The Job lets you cancel the coroutine, check if it is active or completed, and join to wait for its completion.

beginner

Write a simple Kotlin code snippet using launch to print "Hello from coroutine!".

import kotlinx.coroutines.*

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

intermediate

What happens if you call launch inside runBlocking?

The launch coroutine starts concurrently inside the runBlocking scope. The runBlocking waits for all its child coroutines, including the launched one, to complete before finishing.

What does the launch coroutine builder return?

A A Job

B A Deferred

C A Thread

D A Future

launch returns a Job which represents the coroutine's lifecycle.

Which of the following is true about launch?

A It blocks the current thread until completion

B It returns a result directly

C It can only be used in main thread

D It starts a coroutine that runs concurrently

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

How can you cancel a coroutine started with launch?

A By interrupting the thread

B By calling <code>stop()</code> on the coroutine

C By calling <code>cancel()</code> on the Job returned by <code>launch</code>

D By calling <code>await()</code>

The Job returned by launch has a cancel() method to stop the coroutine.

Which coroutine builder should you use if you want a result from the coroutine?

A launch

B async

C runBlocking

D delay

async returns a Deferred which holds the result of the coroutine.

What is the typical use case for launch?

A To perform background work without returning a result

B To compute a value asynchronously

C To block the main thread

D To create a new thread

launch is used for fire-and-forget background tasks that do not return a value.

Explain how the launch coroutine builder works and when you would use it.

Think about starting a task that runs alongside your main program.

Describe the difference between launch and async coroutine builders.

One is for fire-and-forget, the other for getting a value.

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