Why structured concurrency prevents leaks in Kotlin - See It in Action

Why structured concurrency prevents leaks

📖 Scenario: Imagine you are building a simple Kotlin program that launches multiple tasks to fetch data. You want to make sure that when the main task finishes, all child tasks are properly cleaned up and no background work keeps running forever, which can cause memory leaks.

🎯 Goal: You will create a Kotlin program that uses structured concurrency to launch child coroutines inside a scope. You will see how structured concurrency helps prevent leaks by automatically cancelling child tasks when the parent finishes.

📋 What You'll Learn

Create a CoroutineScope with runBlocking

Launch two child coroutines inside the scope

Use delay to simulate work in child coroutines

Cancel the parent scope to stop all child coroutines

Print messages to show when coroutines start and finish

💡 Why This Matters

🌍 Real World

Structured concurrency is used in Kotlin apps to manage background tasks safely, avoiding memory leaks and unexpected behavior.

💼 Career

Understanding structured concurrency is important for Kotlin developers working on Android apps or backend services to write reliable and maintainable asynchronous code.

1

Create a runBlocking scope

Write a Kotlin program that starts with fun main() and inside it, create a runBlocking block assigned to scope.

Kotlin

fun main() {
    val scope = runBlocking {
        // Your code here
    }
}

Need a hint?

Use val scope = runBlocking { } inside main to create a coroutine scope.

2

Launch two child coroutines inside scope

Inside the runBlocking block assigned to scope, launch two child coroutines named job1 and job2 using launch. Each coroutine should print a start message, delay for 1000 milliseconds, then print a finish message.

Kotlin

import kotlinx.coroutines.*

fun main() {
    val scope = runBlocking {
        // Launch job1 coroutine
        // Launch job2 coroutine
    }
}

Need a hint?

Use val job1 = launch { ... } and val job2 = launch { ... } inside runBlocking.

3

Cancel the scope to stop all child coroutines

After launching job1 and job2, add a line to cancel the scope using scope.cancel(). This will stop all running child coroutines.

Kotlin

import kotlinx.coroutines.*

fun main() {
    val scope = runBlocking {
        val job1 = launch {
            println("Job1 started")
            delay(1000)
            println("Job1 finished")
        }
        val job2 = launch {
            println("Job2 started")
            delay(1000)
            println("Job2 finished")
        }
        // Cancel the scope here
    }
}

Need a hint?

Call cancel() inside runBlocking to stop all child coroutines.

4

Print a message after cancelling to show completion

After the runBlocking block, add a println statement that prints "Scope cancelled, all child coroutines stopped".

Kotlin

import kotlinx.coroutines.*

fun main() {
    val scope = runBlocking {
        val job1 = launch {
            println("Job1 started")
            delay(1000)
            println("Job1 finished")
        }
        val job2 = launch {
            println("Job2 started")
            delay(1000)
            println("Job2 finished")
        }
        this.cancel()
    }
    // Print completion message here
}

Need a hint?

Use println("Scope cancelled, all child coroutines stopped") after the runBlocking block.