Что означает ключевое слово suspend в корутинах Kotlin?

Что такое suspend-функция и зачем она нужна?

Ключевое слово suspend в Kotlin — это маркер, который говорит компилятору: "Эта функция может быть приостановлена (suspended) в любой момент и возобновлена позже, не блокируя поток". Это главное отличие от обычных блокирующих функций, таких как Thread.sleep().

Обычная функция, вызывающая Thread.sleep(2000), блокирует текущий поток на 2 секунды. Поток не может делать ничего другого в это время. Suspend-функция, вызывающая delay(2000), приостанавливает выполнение корутины, но не блокирует поток. Поток освобождается для выполнения других корутин или задач, а когда задержка заканчивается, корутина возобновляется на любом свободном потоке (не обязательно на том же).

Почему нельзя вызывать suspend-функцию из обычной функции?

Компилятор запрещает это, потому что обычная функция не имеет "контекста корутины" — специального объекта, который хранит состояние приостановленной функции и знает, как её возобновить. Suspend-функции — это не просто функции, они под капотом превращаются в state-машину (конечный автомат). Компилятор генерирует дополнительный код для сохранения и восстановления локальных переменных при приостановке.

Чтобы вызвать suspend-функцию, нужно находиться внутри:

• Другой suspend-функции
• Блока корутины (например, launch или async)

Правильный способ вызова suspend-функции

Вот как исправить ваш пример:

import kotlinx.coroutines.*

suspend fun fetchUserDataSuspend(): String {
    delay(2000) // неблокирующая задержка
    return "User data loaded"
}

fun main() = runBlocking { // runBlocking создаёт блокирующий мост для корутин
    println("Start")
    val result = fetchUserDataSuspend() // теперь можно! Мы внутри корутины
    println(result)
    println("End")
}

runBlocking — это специальная функция, которая блокирует текущий поток до завершения корутины. Она нужна только в точках входа (например, в main или в тестах). В реальном приложении (Android, сервер) вы будете использовать launch или async внутри корутинного контекста.

Как это работает под капотом (упрощённо)?

Когда компилятор видит suspend, он преобразует функцию в конечный автомат. Представьте, что функция fetchUserDataSuspend разбивается на части:

• Состояние 0: Начало. Выполняется до первого вызова delay.
• Состояние 1: После delay. Возвращает результат.

Каждый вызов delay или другой suspend-функции — это точка приостановки. Когда корутина приостанавливается, её состояние (локальные переменные, номер точки приостановки) сохраняется в специальном объекте. Когда корутина готова продолжить (например, прошло 2 секунды), планировщик корутин возобновляет её с сохранённой точки.

Ключевые отличия от async/await в других языках

В отличие от C# или JavaScript, где async функция возвращает Task/Promise, в Kotlin suspend-функция не обязана возвращать специальный тип. Она может возвращать любое значение напрямую. Это делает код более естественным и похожим на синхронный.

Практический пример с несколькими suspend-вызовами

suspend fun fetchUser(): String {
    delay(1000) // имитация запроса к API
    return "User: John"
}

suspend fun fetchOrders(user: String): List<String> {
    delay(1500)
    return listOf("Order1", "Order2")
}

fun main() = runBlocking {
    val user = fetchUser() // приостанавливается на 1 сек
    val orders = fetchOrders(user) // приостанавливается на 1.5 сек
    println("$user has orders: $orders")
    // Время выполнения: ~2.5 секунды, но поток не блокировался!
}

Если бы вы использовали Thread.sleep, поток был бы заблокирован на 2.5 секунды. С корутинами поток свободен для других задач между приостановками.

Резюме

• suspend — это не "асинхронность", а возможность приостановить выполнение без блокировки потока.
• Вызов suspend-функции возможен только из корутины или другой suspend-функции.
• Под капотом — конечный автомат, который эффективно управляет состоянием.
• Корутины не магия — они просто позволяют писать асинхронный код в синхронном стиле.

// Callback-style (без suspend)
fun fetchUser(callback: (String) -> Unit) {
    thread {
        Thread.sleep(1000)
        callback("User")
    }
}

// Suspend-style
suspend fun fetchUser(): String {
    delay(1000)
    return "User"
}