Why coroutines matter for async programming in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this coroutine example?

Consider this Kotlin coroutine code snippet. 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, World!

D Compilation error

💡 Hint

Remember that launch starts a coroutine that runs concurrently, and delay suspends it without blocking the main thread.

The launch coroutine starts and delays for 100 milliseconds before printing "World!". Meanwhile, the main coroutine prints "Hello," immediately. So the output is "Hello," first, then "World!" on the next line.

🧠 Conceptual

intermediate

Why are coroutines preferred over threads for async tasks?

Which reason best explains why coroutines are preferred over traditional threads for asynchronous programming in Kotlin?

A Coroutines run on separate CPU cores automatically, unlike threads.

B Coroutines do not require any scheduler to run, unlike threads.

C Coroutines can only run synchronously, making them simpler than threads.

D Coroutines are lightweight and use less memory than threads, allowing many to run concurrently without heavy resource use.

💡 Hint

Think about resource use and how many tasks you can run at once.

Coroutines are lightweight and managed by the Kotlin runtime, so you can run thousands without the heavy memory and context-switching costs of threads. This makes async programming more efficient.

🔧 Debug

advanced

Identify the runtime error in this coroutine code

What runtime error will this Kotlin coroutine code produce?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        delay(1000L)
        println("Task finished")
    }
    job.cancel()
    println("Job cancelled")
}

A CancellationException thrown and program crashes

B No error; output is 'Job cancelled' only

C Deadlock occurs and program hangs

D Compilation error due to missing try-catch

💡 Hint

Consider what happens when you cancel a coroutine job before it finishes.

Cancelling a coroutine job stops its execution silently. The program prints "Job cancelled" immediately. The delayed print inside the coroutine never happens, but no exception crashes the program.

📝 Syntax

advanced

Which option correctly launches a coroutine with a delay?

Which Kotlin code snippet correctly launches a coroutine that waits 500ms and then prints "Done"?

A

launch {
    delay(500)
    println("Done")
}

B

launch {
    Thread.sleep(500L)
    println("Done")
}

C

launch {
    delay(500L)
    println("Done")
}

D

launch {
    delay(500L)
    print("Done")
}

💡 Hint

Check the delay parameter type and the print function used.

The delay function requires a Long parameter, so 500L is correct. Using 500 (Int) causes a type error. Also, println prints with a newline, matching the expected output. Thread.sleep blocks the thread and is not a coroutine suspend function.

🚀 Application

expert

How many coroutines run concurrently in this example?

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 because of delay

💡 Hint

Think about how launch and repeat work together.

The repeat(3) launches 3 separate coroutines immediately. They run concurrently, each delaying a different amount before printing. So all 3 coroutines run at the same time.