Why structured concurrency prevents leaks in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of coroutine scope with structured concurrency

What is the output of this Kotlin code using structured concurrency?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(100)
        println("Task 1 done")
    }
    launch {
        delay(50)
        println("Task 2 done")
    }
    println("Main done")
}

A Main done\nTask 2 done\nTask 1 done

B Main done

C Task 1 done\nTask 2 done\nMain done

D Task 2 done\nTask 1 done

💡 Hint

Remember that runBlocking waits for all launched coroutines inside it to complete before finishing.

runBlocking waits for all child coroutines launched inside it to finish before it completes. So "Main done" prints first, then the two tasks print after their delays.

🧠 Conceptual

intermediate

Why does structured concurrency prevent coroutine leaks?

Which statement best explains why structured concurrency prevents coroutine leaks in Kotlin?

A Because Kotlin coroutines use garbage collection to clean up leaked coroutines.

B Because coroutines run on a single thread and cannot leak resources.

C Because coroutines automatically restart if they fail, preventing leaks.

D Because all child coroutines are tied to a parent scope and must complete or cancel before the parent finishes.

💡 Hint

Think about how coroutine lifecycles are managed in structured concurrency.

Structured concurrency ties child coroutines to a parent scope, so the parent waits for children to finish or cancels them, preventing orphaned coroutines that leak resources.

🔧 Debug

advanced

Identify the leak caused by missing coroutine scope

What error or problem occurs when launching a coroutine without a proper parent scope in Kotlin?

Kotlin

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        delay(1000)
        println("Leaked coroutine finished")
    }
    println("Main finished")
}

A The coroutine will throw a CancellationException immediately.

B The program will not compile due to missing coroutine scope.

C The coroutine may continue running after main ends, causing a resource leak.

D The coroutine will block the main thread until it finishes.

💡 Hint

Consider what happens when coroutines are launched in GlobalScope.

Using GlobalScope launches coroutines that are not tied to any lifecycle, so they can outlive the caller and cause leaks.

📝 Syntax

advanced

Correct syntax for structured concurrency with coroutineScope

Which option correctly uses structured concurrency to launch two child coroutines and waits for both to finish?

Kotlin

import kotlinx.coroutines.*

suspend fun doWork() = coroutineScope {
    // launch two child coroutines here
}

A runBlocking { launch { println("Child 1") } }

B

launch { delay(100); println("Child 1") }
launch { delay(200); println("Child 2") }

C

async { println("Child 1") }
async { println("Child 2") }

D

GlobalScope.launch { println("Child 1") }
GlobalScope.launch { println("Child 2") }

💡 Hint

Inside coroutineScope, use launch to start child coroutines tied to the scope.

Using launch inside coroutineScope creates child coroutines that the scope waits for before completing, ensuring structured concurrency.

🚀 Application

expert

How structured concurrency handles exceptions to prevent leaks

Given this code, what happens when one child coroutine throws an exception inside coroutineScope?

Kotlin

import kotlinx.coroutines.*

suspend fun main() = coroutineScope {
    launch {
        delay(100)
        throw RuntimeException("Error in child 1")
    }
    launch {
        delay(200)
        println("Child 2 finished")
    }
}

A The exception cancels the entire coroutineScope, so Child 2 is cancelled and "Child 2 finished" is not printed.

B The exception is ignored, and Child 2 runs to completion printing "Child 2 finished".

C The exception crashes the program immediately without cancelling Child 2.

D The exception is caught automatically and printed, but both children complete.

💡 Hint

Think about how coroutineScope handles exceptions from child coroutines.

coroutineScope cancels all children if any child throws an exception, preventing leaks by not leaving orphan coroutines running.