Launch coroutine builder in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to launch a coroutine that prints "Hello".

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    [1] {
        println("Hello")
    }
}

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

Adelay

Basync

Crun

Dlaunch

Attempts:

3 left

💡 Hint

Common Mistakes

Using async instead of launch when no result is needed.

Trying to call delay directly without a coroutine builder.

The launch builder starts a new coroutine without blocking the current thread.

2fill in blank

medium

Complete the code to launch a coroutine that delays for 1000ms before printing "Done".

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        [1](1000)
        println("Done")
    }
}

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

Await

Bdelay

Cpause

Dsleep

Attempts:

3 left

💡 Hint

Common Mistakes

Using Thread.sleep which blocks the thread instead of suspending the coroutine.

Using incorrect function names like wait or pause.

The delay function suspends the coroutine without blocking the thread.

3fill in blank

hard

Fix the error in the code to correctly launch a coroutine inside runBlocking.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    [1] {
        println("Inside coroutine")
    }
}

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

Alaunch

Brun

Casync

DcoroutineScope

Attempts:

3 left

💡 Hint

Common Mistakes

Using run which is not a coroutine builder.

Using coroutineScope without proper context.

The launch builder is the correct way to start a coroutine inside runBlocking.

4fill in blank

hard

Fill both blanks to launch a coroutine that prints the thread name.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    [1] {
        println("Running on: " + Thread.[2]().name)
    }
}

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

Alaunch

BcurrentThread

CmainThread

Dasync

Attempts:

3 left

💡 Hint

Common Mistakes

Using mainThread which does not exist.

Using async when no result is needed.

launch starts the coroutine, and Thread.currentThread gets the current thread.

5fill in blank

hard

Fill all three blanks to launch a coroutine that delays and then prints a message with the delay time.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val time = 500L
    [1] {
        [2](time)
        println("Waited for [3] ms")
    }
}

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

Alaunch

Bdelay

Ctime

Dasync

Attempts:

3 left

💡 Hint

Common Mistakes

Using async instead of launch when no result is needed.

Using a literal number instead of the variable time in the print statement.

launch starts the coroutine, delay suspends it, and time is the variable holding the delay duration.

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