launch — lényege, fire-and-forget korutinok indítása és működése

Mi a launch a Kotlin Coroutines-ben?

launch — egy Kotlin kiterjesztő függvény, amely a kotlinx.coroutines importon keresztül érhető el, és egy új korutint hoz létre a megadott CoroutineScope-ban. A szokásos függvényektől eltérően a launch-on belüli kód konkurensen hajtódik végre — a korutin felfüggeszthető (suspend) a szál blokkolása nélkül, és később folytatható.

A launch builder a Kotlin korutin modell alapvető építőköve. Nem ad vissza számított értéket, de visszaad egy Job objektumot, amely lehetővé teszi a korutin végrehajtásának vezérlését. A launch-on keresztül egy másik korutinban indított összes gyermek korutin a szülőhöz kapcsolódik.

A launch szintaxisa és paraméterei

A launch builder inline függvényként van definiálva több paraméterrel: CoroutineScope, CoroutineContext, CoroutineStart és suspend-blokk. A paraméterek alapértelmezett értékekkel rendelkeznek, ami a launch-ot kényelmessé teszi tipikus forgatókönyvekhez.

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

A context paraméter egy CoroutineContext-et fogad el, amely egyesíti a diszpécsert, a kivételkezelőt és egy elnevezett elemet. Leggyakrabban Dispatchers.IO, Dispatchers.Main vagy SupervisorJob kerül átadásra a hibák elkülönítéséhez.

Job és életciklus kezelés

Job — a visszaadott objektum, amely a korutin életciklusát képviseli. A Job a következő állapotokban lehet: New, Active, Completing, Completed, Cancelling, Cancelled. Minden állapot tükrözi a végrehajtás státuszát és lehetővé teszi a változásokra való reagálást.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("Előrehaladás: $i")
    }
}

println("A Job aktív: ${job.isActive}")
delay(2500L)
job.cancel()
println("A Job törölve: ${job.isCancelled}")

A Job támogatja a hierarchiát: ha a szülő korutin törlésre kerül, az összes gyermek automatikusan törlődik. A SupervisorJob megváltoztatja ezt a viselkedést — a gyermek korutinok nem törlődnek az egyikük hibája esetén.

Strukturált konkurencia a launch-ban

A strukturált konkurencia azt jelenti, hogy minden korutin egy meghatározott CoroutineScope-ban indul, és a scope nem fejeződik be, amíg az összes gyermek korutin be nem fejezi a munkáját. A launch teljes mértékben támogatja ezt az elvet — a másik korutinban indított korutinok annak gyermekei.

Beágyazott launch hívások

Beágyazott launch indításakor egy korutin fa jön létre. A szülő korutin megvárja az összes gyermek befejeződését, ami kiszámítható végrehajtási sorrendet garantál és leegyszerűsíti az erőforrás-kezelést.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("1. gyermek befejeződött")
        }
        launch {
            delay(500L)
            println("2. gyermek befejeződött")
        }
        println("Minden gyermek befejeződött e sor előtt")
    }
}

Ez a viselkedés eltér a szál alapú konkurenciától, ahol a gyermek szálak nem kapcsolódnak a szülőhöz. Korutinokban a szülő nem fejeződik be, amíg az összes gyermek be nem fejezi a munkáját.

Kivételek kezelése a launch-ban

A kivételek kezelése a launch-ban a Job típusától függ. Egy szokásos Job esetén a kivételek terjednek a szülő korutinra és törlik azt. SupervisorJob vagy SupervisorScope esetén a kivételek elkülönülnek — egy gyermek korutin hibája nem érinti a többit.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Elkapva: ${e.message}")
    }
}
scope.launch {
    println("Ez még mindig működik a SupervisorJob-nak köszönhetően")
}

A le nem kezelt kivételek globális kezeléséhez CoroutineExceptionHandler használatos. Ez elkapja azokat a kivételeket, amelyek nem lettek kezelve a korutinban, és lehetővé teszi a hiba naplózását az alkalmazás összeomlása nélkül.

Példák a launch használatára Android-ban

Android-ban a launch mindenhol alkalmazásra kerül: a ViewModel-től a WorkManager-ig. A fő minta a lifecycleScope használata Fragment-ben és a viewModelScope használata ViewModel-ben a korutinok automatikus törléséhez a komponens életciklusának végén.

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) }
            }
        }
    }
}

A viewModelScope automatikusan törli a korutinokat a ViewModel megsemmisülésekor. Ez kiküszöböli a memóriaszivárgásokat és garantálja, hogy a háttérműveletek nem folytatódnak a kontextus elvesztése után. Ezenkívül a withContext használható a diszpécserek közötti váltáshoz.