Kotlin Coroutines Cheat Sheet

import kotlinx.coroutines.*fun main() = runBlocking {    // launch: fire-and-forget coroutine, returns a Job    val job = launch {        delay(1000L)        println("World!")    }    println("Hello,")    job.join() // wait for the coroutine to finish    // async: returns a Deferred<T>, use .await() to get the result    val deferred: Deferred<Int> = async {        delay(500L)        21    }    println("Answer: ${deferred.await() * 2}")}

// suspend functions can call other suspend functions and be paused/resumedsuspend fun fetchUser(id: Int): String {    delay(300) // non-blocking delay, suspends the coroutine    return "User$id"}suspend fun fetchAndPrint(id: Int) {    val user = fetchUser(id) // suspension point    println(user)}// suspend functions can only be called from a coroutine or another suspend funfun main() = runBlocking {    fetchAndPrint(1)}

import kotlinx.coroutines.*class UserRepository {    // CoroutineScope tied to this class's lifecycle    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())    fun loadUsers() {        scope.launch {            val users = fetchUsers() // child coroutine            println(users)        }    }    fun cancelAll() {        scope.cancel() // cancels all children started in this scope    }}suspend fun fetchUsers(): List<String> = coroutineScope {    // coroutineScope suspends until all children complete; propagates errors    val a = async { fetchUser(1) }    val b = async { fetchUser(2) }    listOf(a.await(), b.await())}

import kotlinx.coroutines.flow.*fun countdown(from: Int): Flow<Int> = flow {    for (i in from downTo 1) {        delay(100)        emit(i) // suspending emission of the next value    }}suspend fun main() {    countdown(3)        .map { it * 10 }        .filter { it > 10 }        .collect { value -> println(value) } // terminal operator, starts the flow}// StateFlow: hot, state-holder flow with an initial valueval state = MutableStateFlow(0)state.value = 1

import kotlinx.coroutines.*// CoroutineExceptionHandler catches uncaught exceptions from launch (not async)val handler = CoroutineExceptionHandler { _, exception ->    println("Caught $exception")}fun main() = runBlocking {    // With a regular Job, one child failing cancels all siblings    val scope = CoroutineScope(Job())    scope.launch(handler) {        launch { throw RuntimeException("child 1 failed") }        launch { delay(1000); println("never printed, sibling was cancelled") }    }    delay(200)    // SupervisorJob: a failing child does NOT cancel its siblings    val supervisor = CoroutineScope(SupervisorJob())    supervisor.launch(handler) { throw RuntimeException("isolated failure") }    supervisor.launch { delay(300); println("still runs") }    delay(500)    // async exceptions are stored and only rethrown on await()    val deferred = scope.async { throw IllegalStateException("boom") }    try {        deferred.await()    } catch (e: IllegalStateException) {        println("await rethrew: ${e.message}")    }}

import kotlinx.coroutines.*fun main() = runBlocking {    val job = launch(Dispatchers.Default) {        var i = 0        while (isActive) { // checks cancellation cooperatively            if (i % 1_000_000 == 0) ensureActive() // throws CancellationException if cancelled            i++        }    }    delay(100)    job.cancelAndJoin() // requests cancellation and suspends until it finishes    // withTimeout throws TimeoutCancellationException if the block runs too long    try {        withTimeout(500) {            delay(1000)        }    } catch (e: TimeoutCancellationException) {        println("timed out")    }    // withTimeoutOrNull returns null instead of throwing    val result = withTimeoutOrNull(500) { delay(1000); "done" }    println(result) // null    // finally blocks still run on cancellation, but suspend calls inside    // finally need withContext(NonCancellable) to actually execute    launch {        try {            delay(1000)        } finally {            withContext(NonCancellable) {                delay(100) // cleanup that must complete even though we're cancelled                println("cleanup done")            }        }    }.cancelAndJoin()}

import kotlinx.coroutines.*import kotlinx.coroutines.channels.*fun main() = runBlocking {    val channel = Channel<Int>(capacity = 2) // buffered channel    val producer = launch {        for (x in 1..5) {            channel.send(x) // suspends when the buffer is full        }        channel.close() // signals no more elements to consumers    }    val consumer = launch {        for (value in channel) { // iterates until the channel is closed            println("received $value")        }    }    joinAll(producer, consumer)    // produce { } builds a channel-backed coroutine, common producer pattern    val squares = produce {        for (x in 1..3) send(x * x)    }    squares.consumeEach { println(it) }}

import kotlinx.coroutines.flow.*import kotlinx.coroutines.*suspend fun main() {    val names = flowOf("Ana", "Bo")    val ages = flowOf(30, 25)    // combine: emits whenever either source flow emits a new value    names.combine(ages) { name, age -> "$name is $age" }        .collect { println(it) }    // flatMapLatest: cancels the previous inner flow when a new value arrives    flowOf(1, 2, 3)        .flatMapLatest { value ->            flow {                delay(100)                emit(value * 10)            }        }        .collect { println(it) }    // buffer: lets the producer run ahead of a slow collector, decoupling stages    flow {        for (i in 1..3) { delay(100); emit(i) }    }.buffer().collect { delay(300); println(it) }    // catch + retry for resilient upstream error handling    flow<Int> { throw RuntimeException("network error") }        .retry(2) { e -> e is RuntimeException }        .catch { e -> println("gave up: ${e.message}") }        .collect()}