Suspend Functions

A suspend function is one that's allowed to pause partway through and let other work happen, then pick back up right where it left off.

In this page:

Declaring a Suspend Function
Suspend Functions Can Only Be Called from Coroutines
delay() vs Thread.sleep()
Composing Suspend Functions

Declaring a Suspend Function

Adding suspend before fun marks a function as one that can pause execution at certain points and resume later, without ever blocking the thread it runs on.

Warning: This example uses kotlinx.coroutines, which is not part of the plain Kotlin standard library. It requires the kotlinx-coroutines-core dependency (added via Gradle/Maven) to compile and run.

Example: Declaring a Suspend Function

markup

import kotlinx.coroutines.*

suspend fun fetchGreeting(): String {
    delay(50)
    return "Hello from a suspend function"
}

fun main() = runBlocking {
    println(fetchGreeting())
}

Suspend Functions Can Only Be Called from Coroutines

A suspend function cannot be called from ordinary code directly -- it must be called from another suspend function or from inside a coroutine builder such as launch or runBlocking.

Example: Suspend Functions Can Only Be Called from Coroutines

markup

import kotlinx.coroutines.*

suspend fun step1(): String {
    delay(20)
    return "step1 done"
}

suspend fun step2(): String {
    delay(20)
    return "step2 done"
}

fun main() = runBlocking {
    println(step1())
    println(step2())
}

delay() vs Thread.sleep()

delay() suspends the coroutine without blocking its underlying thread, allowing that thread to do other work meanwhile, unlike Thread.sleep() which blocks the entire thread outright.

Example: delay() vs Thread.sleep()

markup

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(100)
        println("Task A finished")
    }
    println("Main coroutine continues immediately")
}

Composing Suspend Functions

Suspend functions can call other suspend functions directly, letting you build up sequential asynchronous logic that reads just like ordinary, synchronous-looking code.

Example: Composing Suspend Functions

markup

import kotlinx.coroutines.*

suspend fun fetchUser(): String {
    delay(30)
    return "Ana"
}

suspend fun greetUser(): String {
    val name = fetchUser()
    return "Hello, $name!"
}

fun main() = runBlocking {
    println(greetUser())
}

Common Mistakes

Trying to call a suspend function from ordinary, non-suspending code without a coroutine builder or another suspend function to call it from.
Assuming suspend makes a function automatically run on a background thread; it only marks that it *can* suspend, the actual threading depends on the dispatcher used.
Forgetting that suspension points (like delay) only actually pause execution, they don't block the underlying thread the coroutine is running on.

Chapter Summary

The suspend keyword marks a function that can pause its execution and resume later without blocking a thread.
A suspend function can only be called from another suspend function or from within a coroutine builder like launch/runBlocking.
delay() is a suspend function that pauses a coroutine without blocking the underlying thread, unlike Thread.sleep().
Marking a function suspend does not, by itself, move its work to a background thread.

🔒

Chapter Quiz — Complete all 7 topics to unlock

0/7 topics done

Complete these topics first:

← Previous Lesson launch and async Next Lesson → Dispatchers

Suspend Functions

Declaring a Suspend Function

Suspend Functions Can Only Be Called from Coroutines

delay() vs Thread.sleep()

Composing Suspend Functions

Chapter Quiz — Complete all 7 topics to unlock

Login to run this code