За счет чего можно приостанавливать и возобновлять корутины

Механизмы приостановки и возобновления корутин

Корутины в Kotlin могут приостанавливать и возобновлять своё выполнение благодаря уникальному механизму компиляции и встроенным примитивам управления состоянием.

1. Suspend функции и State Machine

Когда компилятор встречает suspend функцию, он преобразует её в конечный автомат (state machine), способный сохранять состояние:

suspend fun fetchUser(id: Int): User {
    val data = apiService.getUser(id)  // Suspend точка
    return processData(data)  // Ещё одна suspend точка
}

Компилятор преобразует это в состояния:

• State 0: начало выполнения
• State 1: ждём результат apiService.getUser
• State 2: ждём processData
• State 3: возврат результата

2. Continuation как ключ

Объект Continuation содержит информацию о том, как и где возобновить выполнение:

public interface Continuation<in T> {
    val context: CoroutineContext
    fun resumeWith(result: Result<T>)
}

Когда операция завершается (например, сетевой запрос получает ответ), система вызывает resumeWith() с результатом, и корутина возобновляется.

3. CoroutineContext и Dispatcher

Определяет, в каком контексте (потоке) корутина будет возобновлена:

launch(Dispatchers.Main) {
    val data = withContext(Dispatchers.IO) {
        database.getUser(id)  // Приостанавливается в IO потоке
    }
    // Возобновляется в Main потоке
    updateUI(data)
}

4. Job как жизненный цикл

Job управляет жизненным циклом корутины:

val job = launch {
    repeat(100) {
        println("Working")
        delay(1000)  // Suspend точка
    }
}

job.cancel()  // Отменить
job.join()    // Дождаться завершения

Практические примеры

delay() — встроенная приостановка

launch {
    println("Start at ${System.currentTimeMillis()}")
    delay(2000)  // Приостанавливает на 2 сек
    println("End at ${System.currentTimeMillis()}")
}

Параллельное выполнение с async/await

suspend fun loadUserData() = coroutineScope {
    val userAsync = async { apiService.getUser() }
    val settingsAsync = async { database.getSettings() }
    
    UserData(
        user = userAsync.await(),     // Приостанавливается
        settings = settingsAsync.await()  // Приостанавливается
    )
}

withContext для переключения контекста

launch(Dispatchers.Main) {
    showLoading()
    
    val result = withContext(Dispatchers.IO) {
        // Приостанавливается здесь
        performHeavyComputation()
    }
    
    // Возобновляется в Main потоке
    updateUI(result)
}

Почему это работает на JVM

На уровне JVM корутина НЕ потребляет ресурсы потока при приостановке. Когда корутина приостанавливается, освобождается ресурс потока, который может использоваться другой корутиной. Это позволяет тысячам корутин работать в одном потоке без создания новых потоков (что очень дорого).

Ключевые функции управления

• delay(ms) — приостанавливает на время
• await() — ждёт результат async
• join() — ждёт завершения Job
• withContext(dispatcher) — переключает контекст
• yield() — даёт шанс другим корутинам

Best Practices

• Используй suspend функции вместо callbacks
• Явно указывай Dispatcher для ясности
• Используй withContext() для блокирующих операций
• Структурируй корутины с viewModelScope или lifecycleScope
• Помни о отмене через Job.cancel()

Этот механизм делает асинхронное программирование в Kotlin исключительно элегантным и эффективным, позволяя писать асинхронный код как синхронный.