Why structured concurrency prevents leaks in Kotlin - Quick Recap

Recall & Review

beginner

What is structured concurrency in Kotlin?

Structured concurrency means that all coroutines are started in a specific scope and must complete before the scope ends. This keeps coroutines organized and easy to manage.

beginner

How does structured concurrency help prevent resource leaks?

Because coroutines must finish or be cancelled before the scope ends, resources like memory or threads are cleaned up properly, avoiding leaks.

intermediate

What happens if a coroutine inside a structured scope fails?

The failure cancels all sibling coroutines in the same scope, ensuring no orphan coroutines run and cause leaks.

intermediate

Why is it risky to launch coroutines outside structured concurrency?

Launching coroutines outside a structured scope can create 'orphan' coroutines that run without control, leading to leaks and unpredictable behavior.

beginner

Explain the role of CoroutineScope in structured concurrency.

CoroutineScope defines the lifecycle of coroutines. When the scope ends, all coroutines inside it are cancelled or completed, preventing leaks.

What ensures that coroutines do not outlive their intended lifecycle in Kotlin?

A Structured concurrency with CoroutineScope

B Global variables

C Manual thread management

D Using delays

Structured concurrency uses CoroutineScope to manage coroutine lifecycles, preventing them from running beyond their scope.

What happens when a coroutine fails inside a structured concurrency scope?

A Only the failed coroutine stops, others continue

B Nothing happens, failure is ignored

C The program crashes immediately

D All sibling coroutines in the scope are cancelled

Structured concurrency cancels all sibling coroutines to avoid leaks and inconsistent states.

Why can launching coroutines outside structured concurrency cause leaks?

A Because they may run without a controlling scope

B Because they use too much CPU

C Because they run on the main thread

D Because they are always slow

Without a controlling scope, coroutines can run indefinitely, causing resource leaks.

Which Kotlin feature helps automatically cancel coroutines when no longer needed?

A GlobalScope

B CoroutineScope

C Thread.sleep()

D runBlocking

CoroutineScope manages coroutine lifecycles and cancels them when the scope ends.

Structured concurrency improves code by:

A Making coroutines run forever

B Removing the need for error handling

C Organizing coroutines and preventing leaks

D Running coroutines sequentially only

It organizes coroutines in scopes and ensures proper cancellation to prevent leaks.

Describe how structured concurrency in Kotlin prevents coroutine leaks.

Think about how scopes manage coroutine lifetimes and errors.

Explain why launching coroutines outside structured concurrency can cause problems.

Consider what happens when coroutines have no parent scope.

Practice

1. What is the main reason structured concurrency helps prevent resource leaks in Kotlin?

easy

A. It requires manual task cancellation by the programmer.

B. It automatically frees memory after each line of code.

C. It disables background tasks after 5 seconds.

D. It ensures all tasks start and finish together, avoiding orphaned tasks.

Solution

1. Step 1: Understand structured concurrency concept

   Structured concurrency groups related tasks so they start and finish as a unit.

2. Step 2: Link grouping to resource management

   This grouping prevents tasks from running forever and leaking resources by ensuring no orphaned tasks remain.

3. Final Answer:

   It ensures all tasks start and finish together, avoiding orphaned tasks. -> Option D

4. Quick Check:

   Grouping tasks = prevents leaks [OK]

Hint: Think: tasks grouped start and end together [OK]

Common Mistakes:

• Confusing automatic memory freeing with concurrency
• Believing tasks stop after fixed time automatically
• Assuming manual cancellation is always required

2. Which Kotlin syntax correctly starts a structured concurrency block using coroutineScope?

easy

A. launch { coroutineScope { /* task */ } }

B. coroutineScope() -> launch { /* task */ }

C. coroutineScope { launch { /* task */ } }

D. launch coroutineScope { /* task */ }

Solution

1. Step 1: Recall coroutineScope usage

   In Kotlin, coroutineScope is a suspending function that takes a lambda block where child coroutines run.

2. Step 2: Identify correct syntax

   The correct syntax is coroutineScope { launch { /* task */ } } which starts a structured block with a child coroutine.

3. Final Answer:

   coroutineScope { launch { /* task */ } } -> Option C

4. Quick Check:

   coroutineScope with lambda block = coroutineScope { launch { /* task */ } } [OK]

Hint: coroutineScope takes a lambda block with launch inside [OK]

Common Mistakes:

• Using parentheses incorrectly with coroutineScope
• Placing launch outside coroutineScope block
• Omitting braces for lambda block

3. What will be the output of this Kotlin code snippet?

runBlocking {
  launch {
    delay(100)
    println("Task done")
  }
  println("Start")
}

medium

A. Start

B. Start\nTask done

C. Task done\nStart

D. No output

Solution

1. Step 1: Analyze runBlocking and launch behavior

   runBlocking blocks the main thread until all child coroutines complete. The launch coroutine delays 100ms before printing.

2. Step 2: Trace output order

   "Start" prints immediately, then after 100ms delay, "Task done" prints. So output is "Start" then "Task done".

3. Final Answer:

   Start\nTask done -> Option B

4. Quick Check:

   runBlocking waits, launch delays, prints after Start [OK]

Hint: runBlocking waits for launch; delay prints after Start [OK]

Common Mistakes:

• Assuming launch runs before println("Start")
• Thinking delay blocks main thread
• Expecting no output due to delay

4. Identify the error in this Kotlin code that breaks structured concurrency:

fun main() = runBlocking {
  GlobalScope.launch {
    delay(1000)
    println("Leaked task")
  }
  println("Main done")
}

medium

A. Using GlobalScope.launch causes the task to run outside structured concurrency.

B. Missing delay before println("Main done").

C. runBlocking cannot be used with launch.

D. println("Leaked task") is outside coroutine scope.

Solution

1. Step 1: Understand GlobalScope effect

   GlobalScope.launch starts a coroutine not tied to the current scope, so it can outlive runBlocking.

2. Step 2: Link to structured concurrency principles

   This breaks structured concurrency because the launched task can leak and run after main finishes, causing resource leaks.

3. Final Answer:

   Using GlobalScope.launch causes the task to run outside structured concurrency. -> Option A

4. Quick Check:

   GlobalScope.launch breaks structured concurrency [OK]

Hint: GlobalScope.launch runs outside structured concurrency [OK]

Common Mistakes:

• Thinking delay is required before printing main done
• Believing runBlocking disallows launch
• Misunderstanding println placement

5. You want to run multiple tasks concurrently but ensure none leak after completion. Which Kotlin approach best applies structured concurrency to prevent leaks?

hard

A. Use coroutineScope or supervisorScope to launch child coroutines inside a suspending block.

B. Launch all tasks with GlobalScope.launch and manually cancel them later.

C. Run tasks sequentially without coroutines to avoid leaks.

D. Use runBlocking only for all tasks without launching coroutines.

Solution

1. Step 1: Identify structured concurrency tools

   coroutineScope and supervisorScope provide structured concurrency by grouping child coroutines and waiting for their completion.

2. Step 2: Compare with other options

   GlobalScope.launch risks leaks, sequential runs lose concurrency benefits, and runBlocking alone doesn't manage child coroutines properly.

3. Final Answer:

   Use coroutineScope or supervisorScope to launch child coroutines inside a suspending block. -> Option A

4. Quick Check:

   coroutineScope groups tasks safely [OK]

Hint: Use coroutineScope or supervisorScope for safe concurrency [OK]

Common Mistakes:

• Relying on GlobalScope.launch without cancellation
• Avoiding concurrency to prevent leaks
• Misusing runBlocking without child coroutines