Why coroutines? suspend functions

The main thread problem

A thread is a path of execution: a worker that runs your code step by step. Every Android app has a main thread (also called the UI thread). It draws the screen about 60 or more times a second and responds to taps and swipes. If you make it wait for a slow job, such as downloading data, reading a large file or querying a database, it cannot draw or respond. The app freezes. If an input event is not handled for about 5 seconds, Android shows the "Application Not Responding" (ANR) dialog, and users uninstall apps that do this.

Old solutions and their problems

• Start a new thread for each job: threads are heavy (each uses memory) and passing the result back to the main thread is fiddly.
• Callbacks: "call this function when the download finishes". Several steps in a row become nested callbacks inside callbacks, which is hard to read and to handle errors in.

Coroutines

A coroutine is a lightweight piece of work that can pause and resume. When a coroutine waits for something slow, it suspends: it steps aside and frees the thread to do other work. When the result arrives, it resumes where it left off, possibly on another thread. You can run thousands of coroutines on a few threads. The best part: the code still reads top to bottom, like normal code.

import kotlinx.coroutines.*

suspend fun fetchBalance(): Int {
    delay(1000)          // pretend network call: suspends for 1 second, does not block
    return 2500
}

fun main() = runBlocking {
    println("Loading...")
    val balance = fetchBalance()     // pauses here without freezing the thread
    println("Balance: Rs $balance")
}

suspend functions

The suspend keyword marks a function that may pause. A suspend function can only be called from another suspend function or from inside a coroutine. That rule lets the compiler make sure pausing is always possible where it happens. Libraries you will use, like Retrofit and Room, offer suspend functions for network and database calls.

delay versus Thread.sleep

Setting up

// app/build.gradle.kts
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:<version>")
}

Common mistakes

• Calling a suspend function from a normal function: "Suspend function should be called only from a coroutine or another suspend function".
• Using Thread.sleep inside a coroutine. Use delay.
• Thinking suspend makes code run on a background thread by itself. It only allows pausing; you still choose the thread with dispatchers (topic 3).
• Doing network calls directly on the main thread without coroutines: Android throws NetworkOnMainThreadException.