launch — същност, fire-and-forget стартиране на корутини и как работи

Какво е launch в Kotlin Coroutines?

launch — е разширяваща функция на Kotlin, достъпна чрез import kotlinx.coroutines, която създава нова корутина в зададен CoroutineScope. За разлика от обикновените функции, кодът вътре в launch се изпълнява конкурентно — корутината може да бъде спряна (suspend) без блокиране на нишката и да бъде възобновена по-късно.

Launch builder е фундаментален градивен блок на модела на корутините в Kotlin. Той не връща изчислена стойност, но връща обект Job, който позволява контрол на изпълнението на корутината. Всички дъщерни корутини, стартирани чрез launch вътре в друга корутина, са обвързани с родителската.

Синтаксис и параметри на launch

Launch builder е дефиниран като inline функция с няколко параметъра: CoroutineScope, CoroutineContext, CoroutineStart и suspend-блок. Параметрите имат стойности по подразбиране, което прави launch удобен за типични сценарии.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

Параметърът context приема CoroutineContext, който комбинира диспечера, обработчика на изключения и именуван елемент. Най-често се предават Dispatchers.IO, Dispatchers.Main или SupervisorJob за изолиране на грешки.

Job и управление на жизнения цикъл

Job — върнатият обект, който представлява жизнения цикъл на корутината. Job може да бъде в състояния: New, Active, Completing, Completed, Cancelling, Cancelled. Всяко състояние отразява статуса на изпълнение и позволява реакция на промени.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Напредък: $i")
    }
}

println("Job е активен: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job е отменен: ${job.isCancelled}")

Job поддържа йерархия: ако родителската корутина бъде отменена, всички дъщерни се отменят автоматично. SupervisorJob променя това поведение — дъщерните корутини не се отменят при грешка на една от тях.

Структурирана конкурентност в launch

Структурирана конкурентност означава, че всяка корутина се стартира в определен CoroutineScope и scope не завършва, докато всички дъщерни корутини не приключат работата си. launch напълно поддържа този принцип — корутините, стартирани вътре в друга корутина, са нейни деца.

Вложени launch повиквания

При вложено стартиране на launch се образува дърво от корутини. Родителската корутина изчаква завършването на всички деца, което гарантира предвидим ред на изпълнение и опростява управлението на ресурсите.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Дете 1 завършено")
        }
        launch {
            delay(500L)
            println("Дете 2 завършено")
        }
        println("Всички деца завършени преди този ред")
    }
}

Това поведение се различава от конкурентността, базирана на нишки, където дъщерните нишки не са обвързани с родителската. При корутините родителят не завършва, докато всички деца не приключат работата си.

Обработка на изключения в launch

Обработката на изключения в launch зависи от типа на Job. За обикновен Job изключенията се разпространяват към родителската корутина и я отменят. За SupervisorJob или SupervisorScope изключенията са изолирани — грешката на една дъщерна корутина не засяга останалите.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Уловено: ${e.message}")
    }
}
scope.launch {
    println("Това все още работи благодарение на SupervisorJob")
}

За глобална обработка на неуловени изключения се използва CoroutineExceptionHandler. Той улавя изключения, които не са били обработени вътре в корутината, и позволява регистриране на грешката без срив на приложението.

Примери за използване на launch в Android

В Android launch се използва навсякъде: от ViewModel до WorkManager. Основният модел е използването на lifecycleScope във Fragment и viewModelScope в ViewModel за автоматично отменяне на корутини при завършване на жизнения цикъл на компонента.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope автоматично отменя корутините при унищожаване на ViewModel. Това елиминира изтичания на памет и гарантира, че фоновите операции не продължават след загуба на контекст. Допълнително може да се използва withContext за превключване между диспечери.