Launch coroutine builder in Kotlin

Introduction

The launch coroutine builder lets you start a new task that runs in the background without blocking the main program. It helps you do many things at once easily.

When you want to run a task that does not return a result and can run alongside other tasks.

When you need to perform background work like fetching data or waiting for a timer without freezing the app.

When you want to start a task that can be cancelled later if needed.

When you want to keep your app responsive by running long tasks outside the main thread.

Syntax

Kotlin

launch(context) {
    // code to run in coroutine
}

launch starts a new coroutine immediately.

The context is optional and defines where the coroutine runs (like on the main thread or background).

Examples

Starts a coroutine on the default dispatcher and prints a message.

Kotlin

launch {
    println("Hello from coroutine!")
}

Starts a coroutine on a background thread for input/output tasks.

Kotlin

launch(Dispatchers.IO) {
    // Run blocking IO task here
}

Starts a coroutine that can be cancelled before it finishes.

Kotlin

val job = launch {
    delay(1000L)
    println("Task done")
}

job.cancel()

Sample Program

This program starts a coroutine that waits half a second and then prints "World!" while the main coroutine prints "Hello," immediately. The delay at the end keeps the program running so we see both messages.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(500L)
        println("World!")
    }
    println("Hello,")
    delay(1000L) // Wait to keep JVM alive
}

Important Notes

launch returns a Job which you can use to cancel or check the coroutine.

Coroutines started with launch do not return a result. Use async if you need a result.

Always use runBlocking or another coroutine scope to keep the program alive when testing coroutines in main.

Summary

launch starts a new coroutine that runs independently.

It is useful for background tasks that do not return a value.

You can control and cancel coroutines using the Job returned by launch.

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