launch, async and structured concurrency

Scopes: where coroutines live

A coroutine is always started from a CoroutineScope, an object that tracks the coroutines started in it. When the scope ends or is cancelled, all its coroutines are cancelled too. This rule, called structured concurrency, prevents work from running forever in the background after a screen is closed, which wastes battery and data and can crash the app.

launch: fire and forget

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job: Job = launch {
        delay(500)
        println("Receipt emailed")
    }
    println("Payment done")
    job.join()            // wait for the job to finish (optional)
}

async: get a result

suspend fun price(): Int { delay(1000); return 499 }
suspend fun stock(): Int { delay(1000); return 12 }

fun main() = runBlocking {
    val p = async { price() }      // both start now
    val s = async { stock() }
    println("Rs ${p.await()}, ${s.await()} left")   // about 1 second in total, not 2
}

Use launch when you do not need a result (save, send, log). Use async when you need a value, and especially to run several independent calls at the same time.

Structured concurrency in practice

suspend fun loadDashboard(): String = coroutineScope {
    val user = async { delay(300); "Asha" }
    val orders = async { delay(500); 7 }
    "${user.await()} has ${orders.await()} orders"
}   // returns only when both children are done; if one fails, the other is cancelled

Cancellation

Cancelling a scope or Job asks its coroutines to stop. Cancellation is cooperative: a coroutine notices it at suspension points like delay, or when it checks isActive. Long CPU loops should call ensureActive() or yield() now and then. Library suspend functions (Retrofit, Room) already cooperate.

fun main() = runBlocking {
    val job = launch {
        repeat(100) { i ->
            println("Uploading part $i")
            delay(100)
        }
    }
    delay(350)
    job.cancel()           // user pressed Cancel
    println("Upload cancelled")
}

Errors

An exception inside launch cancels the parent scope by default and is reported as an uncaught error. Inside async, the exception is thrown when you call await(). The simplest rule: wrap the risky call in try/catch inside the coroutine and turn failures into an error state for the UI.

viewModelScope.launch {
    try {
        val data = repository.load()
        _state.value = UiState.Success(data)
    } catch (e: IOException) {
        _state.value = UiState.Error("No internet connection")
    }
}

Common mistakes

• Using GlobalScope: its coroutines are not tied to any screen and can leak. Use viewModelScope or lifecycleScope.
• Awaiting async calls one by one right after starting each (async { a() }.await()), which removes the speed-up. Start all, then await.
• Catching Exception broadly and swallowing CancellationException, which breaks cancellation.
• Using runBlocking in Android UI code: it freezes the main thread.