Understanding Kotlin Coroutine Suspension: launch, async, and suspend Explained

Recap of the previous episode

In the last episode we covered:

What a coroutine actually is

Why coroutines are useful

How to use coroutines

Most of the time we create coroutines with the launch function, but two other functions can also be used: runBlocking – mainly for unit tests because it blocks the thread. async – returns a Deferred result.

We will now compare launch and async:

Both start a coroutine and return a Coroutine object. async additionally implements the Deferred interface. Deferred represents a value that will be available later; you obtain it with Deferred.await().

What "suspend" really does

When a coroutine reaches a suspend function, the coroutine is paused and detached from the thread that was executing it.

The thread continues its own work (e.g., UI refresh on the main thread or background tasks on a pool thread) while the coroutine is suspended.

After the suspend function completes, the coroutine automatically switches back to the original thread and resumes execution.

This thread‑switching is performed by the coroutine framework, not by the suspend keyword itself. The keyword merely signals that the function is potentially long‑running and must be called from a coroutine.

How suspension is implemented

Suspension happens when a suspend function internally calls another suspend function such as withContext or delay. For example:

suspend fun suspendingGetImage(id: String) = withContext(Dispatchers.IO) {
    // IO work here
}

withContext

receives a Dispatcher (e.g., Dispatchers.IO) that tells the coroutine which thread pool to switch to while the work is performed.

Simply adding the suspend modifier without any real suspension logic results in a compiler warning "redundant suspend modifier" because the function does not actually cause a thread switch.

Custom suspend functions

To create a custom suspend function, add the suspend keyword and wrap the body with a real suspending call like withContext or delay:

suspend fun suspendingPrint() {
    println("Thread: ${Thread.currentThread().name}")
}

Or a function that waits:

suspend fun suspendUntilDone() {
    while (!done) {
        delay(5)
    }
}

These patterns let the coroutine framework handle the actual thread switching and resumption.

Summary

Suspension in Kotlin coroutines is a thread‑scheduling operation that temporarily detaches a coroutine from its current thread, runs the suspend block on the dispatcher‑specified thread, and then automatically switches back to continue execution.

The suspend keyword itself is only a compile‑time reminder that the function must be called from a coroutine.

Next time we will answer common questions such as how non‑blocking suspension works and how coroutines compare to RxJava.