launch — istota, fire-and-forget uruchamianie korutyn i jak działa

Czym jest launch w Kotlin Coroutines?

launch — to funkcja rozszerzająca Kotlin, dostępna przez import kotlinx.coroutines, która tworzy nową korutynę w zadanym CoroutineScope. W przeciwieństwie do zwykłych funkcji, kod wewnątrz launch wykonuje się współbieżnie — korutyna może się zawieszać (suspend) bez blokowania wątku i wznawiać później.

Builder launch jest fundamentalnym blokiem konstrukcyjnym modelu korutyn w Kotlin. Nie zwraca obliczonej wartości, ale zwraca obiekt Job, umożliwiający kontrolowanie wykonania korutyny. Wszystkie korutyny potomne uruchomione przez launch wewnątrz innej korutyny są powiązane z rodzicielską.

Składnia i parametry launch

Builder launch jest zdefiniowany jako funkcja inline z kilkoma parametrami: CoroutineScope, CoroutineContext, CoroutineStart i suspend-block. Parametry mają wartości domyślne, co czyni launch wygodnym dla typowych scenariuszy.

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

Parametr context przyjmuje CoroutineContext, łączący dyspozytora, obsługę wyjątków i nazwany element. Najczęściej przekazywany jest Dispatchers.IO, Dispatchers.Main lub SupervisorJob do izolacji błędów.

Job i zarządzanie cyklem życia

Job — zwracany obiekt reprezentujący cykl życia korutyny. Job może znajdować się w stanach: New, Active, Completing, Completed, Cancelling, Cancelled. Każdy stan odzwierciedla status wykonania i pozwala reagować na zmiany.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Postęp: $i")
    }
}

println("Job jest aktywny: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job jest anulowany: ${job.isCancelled}")

Job wspiera hierarchię: jeśli rodzicielska korutyna zostanie anulowana, wszystkie potomne są automatycznie anulowane. SupervisorJob zmienia to zachowanie — korutyny potomne nie są anulowane przy błędzie jednej z nich.

Ustrukturyzowana współbieżność w launch

Ustrukturyzowana współbieżność oznacza, że każda korutyna jest uruchamiana w określonym CoroutineScope, a scope nie zakończy się, dopóki wszystkie korutyny potomne nie zakończą pracy. launch w pełni wspiera tę zasadę — korutyny uruchomione wewnątrz innej korutyny są jej potomnymi.

Zagnieżdżone wywołania launch

Przy zagnieżdżonym uruchamianiu launch powstaje drzewo korutyn. Rodzicielska korutyna oczekuje na zakończenie wszystkich potomnych, co gwarantuje przewidywalną kolejność wykonania i upraszcza zarządzanie zasobami.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Potomny 1 zakończony")
        }
        launch {
            delay(500L)
            println("Potomny 2 zakończony")
        }
        println("Wszystkie potomne zakończone przed tą linią")
    }
}

To zachowanie różni się od współbieżności opartej na wątkach, gdzie wątki potomne nie są powiązane z rodzicielskim. W korutynach rodzic nie zakończy się, dopóki wszystkie dzieci nie zakończą pracy.

Obsługa wyjątków w launch

Obsługa wyjątków w launch zależy od typu Job. W przypadku zwykłego Job wyjątki rozprzestrzeniają się na rodzicielską korutynę i anulują ją. Dla SupervisorJob lub SupervisorScope wyjątki są izolowane — błąd jednej korutyny potomnej nie wpływa na pozostałe.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Przechwycono: ${e.message}")
    }
}
scope.launch {
    println("To wciąż działa dzięki SupervisorJob")
}

Do globalnej obsługi nieprzechwyconych wyjątków używa się CoroutineExceptionHandler. Przechwytuje on wyjątki, które nie zostały obsłużone wewnątrz korutyny, i umożliwia zalogowanie błędu bez crasha aplikacji.

Przykłady użycia launch w Android

W Android launch jest używany wszechobecnie: od ViewModel do WorkManager. Główny wzorzec — użycie lifecycleScope we Fragment i viewModelScope w ViewModel do automatycznego anulowania korutyn przy zakończeniu cyklu życia komponentu.

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 automatycznie anuluje korutyny przy zniszczeniu ViewModel. Eliminuje to wycieki i gwarantuje, że operacje w tle nie są kontynuowane po utracie kontekstu. Dodatkowo można użyć withContext do przełączania między dyspozytorami.