Kotlin Coroutines Cheat Sheet

⚙️ Kotlin Coroutines Cheat Sheet (For Android Devs)

I like to share content that I use during study and work.
This is a cheatsheet that I used when developing with coroutines.

Coroutines are lightweight threads used for asynchronous and concurrent programming in Kotlin.

They allow you to run tasks like network or DB operations without blocking the main thread.

---

🔹 Core Keywords & Builders

Keyword / Builder	Description
suspend	Marks a function that can be paused and resumed later
launch	Starts a coroutine that doesn’t return a result
async	Starts a coroutine that returns a Deferred result
await()	Waits for the result of an async coroutine
withContext()	Switches the coroutine context (e.g., Main, IO)
runBlocking	Starts a blocking coroutine (usually for testing)
coroutineScope	Creates a new scope that waits for all its children
supervisorScope	Similar to coroutineScope but failures don’t cancel siblings
delay()	Non-blocking sleep function
yield()	Yields execution to other coroutines temporarily

---

🔹 Dispatchers

Dispatcher	Used for
Dispatchers.Main	UI operations (Android main thread)
Dispatchers.IO	I/O tasks: networking, DB, file access
Dispatchers.Default	CPU-intensive work
Dispatchers.Unconfined	Executes in current thread (advanced use)

---

🔹 Example 1: Basic Launch

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000)
        println("World!")
    }
    println("Hello,")
}

Output:

Hello,
World!

🔹 Example 2: async/await

import kotlinx.coroutines.*

suspend fun fetchUser(): String {
    delay(1000)
    return "Bruno"
}

suspend fun fetchPosts(): List<String> {
    delay(1000)
    return listOf("Post 1", "Post 2")
}

fun main() = runBlocking {
    val user = async { fetchUser() }
    val posts = async { fetchPosts() }
    println("User: ${user.await()}, Posts: ${posts.await()}")
}

Output:

User: Bruno, Posts: [Post 1, Post 2]

🔹 Example 3: withContext

import kotlinx.coroutines.*

suspend fun loadUserData() = withContext(Dispatchers.IO) {
    // background work
    "User data loaded"
}

fun main() = runBlocking {
    val result = loadUserData()
    println(result)
}

Output:

User data loaded

🔹 Flow basics

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun numbersFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        emit(i)
        delay(100)
    }
}

fun main() = runBlocking {
    numbersFlow()
        .map { it * 2 }
        .collect { println(it) }
}

Output:

2
4
6

You can try these examples yourself on Kotlin Playground.