Что вызывается в Coroutine

Жизненный цикл Coroutine и ключевые вызовы

В контексте Kotlin Coroutines, под "что вызывается" обычно подразумевается цепочка вызовов, которая происходит при запуске, выполнении и завершении корутины. Давайте разберем это детально.

Основные компоненты вызова

1. Старт корутины

Когда вы запускаете корутину с помощью launch, async или runBlocking, происходит следующее:

import kotlinx.coroutines.*

fun main() = runBlocking {
    // 1. Вызов launch создает новую корутину
    val job = launch {
        // 3. Этот блок кода будет выполнен в корутине
        println("Coroutine is running")
    }
    // 2. Здесь корутина уже запланирована на выполнение
    job.join() // 4. Ожидание завершения
}

Ключевые этапы:

• Dispatcher определяет поток выполнения
• CoroutineContext устанавливает контекст
• Continuation.resume() инициирует выполнение

2. Иерархия вызовов в корутине

Внутри корутины вызываются:

import kotlin.coroutines.*

suspend fun getUserData(): String {
    // suspend-функция
    return "User data"
}

fun main() {
    val continuation = object : Continuation<String> {
        override val context: CoroutineContext
            get() = EmptyCoroutineContext
        
        override fun resumeWith(result: Result<String>) {
            // Этот метод вызывается при завершении
            println("Result: ${result.getOrNull()}")
        }
    }
    
    // Корутина строится на Continuation Passing Style
}

Триггеры вызова suspend-функций

Приостановка и возобновление:

import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

runBlocking {
    launch {
        println("Start")                // 1. Выполняется сразу
        delay(1000)                    // 2. Приостанавливает корутину
        println("After delay")         // 3. Возобновляется после паузы
    }
}

Ключевые методы, которые вызываются:

1. CoroutineScope.launch() → создает Job и запускает корутину
2. CoroutineStart.invoke() → запускает корутину согласно стратегии (LAZY, DEFAULT, etc.)
3. Dispatchers.dispatch() → отправляет корутину на выполнение в нужный поток
4. Continuation.resumeWith() → основной механизм возобновления
5. CancellableContinuation → управляет отменяемыми приостановками

Пример полного жизненного цикла вызовов:

import kotlinx.coroutines.*

fun main() {
    val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
    
    scope.launch {
        // Вызывается цепочка:
        // 1. CoroutineStart.DEFAULT.invoke()
        // 2. Dispatchers.Default.dispatch()
        // 3. ContinuationImpl.resumeWith()
        
        try {
            val data = fetchData() // suspend-функция
            processData(data)      // обычная функция
        } catch (e: Exception) {
            // Обработка исключений
        } finally {
            // finally блок всегда вызывается
        }
    }
}

suspend fun fetchData(): String {
    delay(500)
    return "Data"
}

Важные аспекты:

• Structured Concurrency: родительская корутина вызывает join() или cancel() для дочерних
• Exception Handling: вызываются обработчики исключений через CoroutineExceptionHandler
• Отмена (Cancellation):
  • Вызывается cancel() на Job
  • Проверяется isActive в корутине
  • Выбрасывается CancellationException

Dispatcher и потоки выполнения:

withContext(Dispatchers.IO) {
    // Вызывается смена контекста:
    // 1. Текущая корутина приостанавливается
    // 2. Запускается блок в IO-диспетчере
    // 3. Возвращается к исходному диспетчеру
}

Заключение

В корутинах вызывается сложная цепочка методов и обратных вызовов (callbacks), которые абстрагированы от разработчика. Ключевые элементы:

• Continuation Passing Style - фундаментальная концепция
• CoroutineContext - хранит контекст выполнения
• Dispatcher - управляет потоками
• Job/Deferred - управляют жизненным циклом

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