Coroutine scope and structured concurrency in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a CoroutineScope in Kotlin?

A CoroutineScope defines the lifecycle of coroutines. It controls when coroutines start and when they are cancelled, helping to manage concurrency safely.

beginner

Explain structured concurrency in Kotlin coroutines.

Structured concurrency means that coroutines are launched in a specific scope and must complete or cancel before the scope ends. This keeps concurrency organized and prevents leaks.

intermediate

What happens when a parent coroutine is cancelled in structured concurrency?

All child coroutines launched in the parent's scope are automatically cancelled, ensuring no orphan coroutines run outside the intended lifecycle.

intermediate

How does launch differ from async in a CoroutineScope?

launch starts a coroutine that returns a Job and is used for tasks without a result. async returns Deferred and is used when you want a result from the coroutine.

beginner

Why is it important to use CoroutineScope for launching coroutines?

Using CoroutineScope ties coroutines to a lifecycle, so they can be cancelled properly. This avoids memory leaks and unexpected behavior in apps.

What does structured concurrency ensure in Kotlin coroutines?

A Child coroutines complete before their parent coroutine ends

B Coroutines run only on the main thread

C Coroutines run independently without any lifecycle control

D Coroutines never get cancelled

Structured concurrency ensures that child coroutines complete or cancel before their parent coroutine ends, keeping concurrency organized.

Which Kotlin function launches a coroutine that returns a result?

A async

B runBlocking

C delay

D launch

async launches a coroutine that returns a Deferred result, which can be awaited.

If a parent coroutine is cancelled, what happens to its child coroutines?

A They continue running independently

B They are also cancelled automatically

C They pause until the parent restarts

D They throw an exception

In structured concurrency, cancelling a parent coroutine automatically cancels all its child coroutines.

What is the role of CoroutineScope in Kotlin?

A It schedules coroutines to run sequentially

B It defines the thread where coroutines run

C It converts coroutines to threads

D It manages the lifecycle of coroutines

CoroutineScope manages the lifecycle of coroutines, controlling their start and cancellation.

Which of these is NOT a benefit of structured concurrency?

A Prevents memory leaks

B Ensures coroutines complete in order

C Allows orphan coroutines to run freely

D Simplifies error handling

Structured concurrency prevents orphan coroutines; allowing them to run freely is not a benefit.

Describe how CoroutineScope helps manage coroutines in Kotlin.

Think about how you keep track of tasks in real life to avoid forgetting them.

Explain the concept of structured concurrency and why it is important.

Imagine a team where everyone finishes their work before the project ends.

Practice

1. What is the main purpose of a CoroutineScope in Kotlin?

easy

A. To block the main thread until coroutines finish

B. To create threads manually for parallel execution

C. To group coroutines and manage their lifecycle together

D. To convert coroutines into synchronous functions

Solution

1. Step 1: Understand CoroutineScope role

   A CoroutineScope groups coroutines so they can be managed as one unit.

2. Step 2: Compare other options

   The other options describe unrelated or incorrect behaviors for CoroutineScope.

3. Final Answer:

   To group coroutines and manage their lifecycle together -> Option C

4. Quick Check:

   CoroutineScope groups coroutines [OK]

Hint: CoroutineScope manages coroutines lifecycle as a group [OK]

Common Mistakes:

• Thinking CoroutineScope creates threads
• Confusing CoroutineScope with blocking calls
• Assuming CoroutineScope converts coroutines to sync

2. Which of the following is the correct way to launch a coroutine within a CoroutineScope?

easy

A. scope.launch { /* coroutine code */ }

B. launch.scope { /* coroutine code */ }

C. CoroutineScope.launch { /* coroutine code */ }

D. scope.run { /* coroutine code */ }

Solution

1. Step 1: Recall coroutine launch syntax

   Within a CoroutineScope, you call launch as a function on the scope instance.

2. Step 2: Check options for syntax correctness

   scope.launch { /* coroutine code */ } uses scope.launch {} which is correct. Others misuse syntax or functions.

3. Final Answer:

   scope.launch { /* coroutine code */ } -> Option A

4. Quick Check:

   launch is called on CoroutineScope instance [OK]

Hint: Use scope.launch { } to start coroutine inside scope [OK]

Common Mistakes:

• Swapping order like launch.scope
• Using run instead of launch
• Calling launch as a static method

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

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        delay(100)
        println("Task done")
    }
    println("Waiting")
    job.join()
    println("Finished")
}

medium

A. Task done\nWaiting\nFinished

B. Waiting\nTask done\nFinished

C. Waiting\nFinished\nTask done

D. Finished\nWaiting\nTask done

Solution

1. Step 1: Analyze coroutine launch and delay

   The coroutine launched delays 100ms before printing "Task done". Meanwhile, "Waiting" prints immediately.

2. Step 2: Understand job.join() effect

   The main coroutine waits for the launched job to finish before printing "Finished".

3. Final Answer:

   Waiting\nTask done\nFinished -> Option B

4. Quick Check:

   Output order respects delay and join [OK]

Hint: join() waits for coroutine to finish before continuing [OK]

Common Mistakes:

• Assuming launched coroutine runs instantly
• Ignoring delay effect
• Printing Finished before job completes

4. Identify the problem in this Kotlin coroutine code and choose the correct fix:

fun main() = runBlocking {
    val job = GlobalScope.launch {
        delay(1000)
        println("Done")
    }
    println("Waiting")
}

medium

A. Replace delay(1000) with Thread.sleep(1000)

B. Use CoroutineScope().launch {} instead of GlobalScope.launch

C. Remove runBlocking and use GlobalScope.launch only

D. Add job.join() after println("Waiting")

Solution

1. Step 1: Identify lifecycle issue with GlobalScope

   Using GlobalScope.launch starts coroutine that may outlive runBlocking, so "Done" may never print.

2. Step 2: Fix by waiting for job completion

   Calling job.join() ensures main coroutine waits for launched coroutine to finish before exiting.

3. Final Answer:

   Add job.join() after println("Waiting") -> Option D

4. Quick Check:

   join() waits for coroutine to complete [OK]

Hint: Always join launched jobs to wait for completion [OK]

Common Mistakes:

• Ignoring job.join() causing premature exit
• Replacing delay with blocking sleep
• Removing runBlocking causing main to exit early

5. Given this Kotlin code using structured concurrency, what will be printed?

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        coroutineScope {
            launch {
                delay(100)
                println("Child 1 done")
            }
            launch {
                delay(50)
                throw RuntimeException("Error in Child 2")
            }
        }
    } catch (e: Exception) {
        println("Caught: " + e.message)
    }
    println("End of main")
}

hard

A. Caught: Error in Child 2\nEnd of main

B. Child 1 done\nCaught: Error in Child 2\nEnd of main

C. Caught: Error in Child 2

D. Child 1 done\nEnd of main

Solution

1. Step 1: Understand coroutineScope behavior on exceptions

   If any child coroutine throws an exception, coroutineScope cancels all children and throws the exception.

2. Step 2: Analyze timing and cancellation

   Child 2 throws after 50ms, cancelling Child 1 before it prints. The exception is caught and message printed.

3. Final Answer:

   Caught: Error in Child 2\nEnd of main -> Option A

4. Quick Check:

   Exception cancels siblings, caught prints message [OK]

Hint: Exception cancels sibling coroutines in coroutineScope [OK]

Common Mistakes:

• Assuming Child 1 prints despite cancellation
• Missing try-catch around coroutineScope
• Thinking exceptions are ignored in coroutineScope