launch — Wesen, Fire-and-Forget-Coroutine-Starten und Funktionsweise

Was ist launch in Kotlin Coroutines?

launch ist eine Kotlin-Erweiterungsfunktion, verfügbar über den Import kotlinx.coroutines, die eine neue Coroutine in einem bestimmten CoroutineScope erstellt. Im Gegensatz zu normalen Funktionen wird der Code innerhalb von launch nebenläufig ausgeführt — die Coroutine kann sich suspendieren, ohne einen Thread zu blockieren, und später wieder aufnehmen.

Der launch-Builder ist ein grundlegender Baustein des Kotlin-Coroutine-Modells. Er gibt keinen berechneten Wert zurück, sondern ein Job-Objekt, das die Kontrolle über die Coroutine-Ausführung ermöglicht. Alle Kind-Coroutinen, die über launch innerhalb einer anderen Coroutine gestartet werden, sind an die Eltern-Coroutine gebunden.

Syntax und Parameter von launch

Der launch-Builder ist als Inline-Funktion mit mehreren Parametern definiert: CoroutineScope, CoroutineContext, CoroutineStart und einem suspend-Block. Die Parameter haben Standardwerte, was launch für typische Szenarien praktisch macht.

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

Der context-Parameter akzeptiert einen CoroutineContext, der einen Dispatcher, einen Ausnahmehandler und ein benanntes Element kombiniert. Am häufigsten werden Dispatchers.IO, Dispatchers.Main oder SupervisorJob zur Fehlerisolierung übergeben.

Job und Lebenszyklusverwaltung

Job — das zurückgegebene Objekt, das den Lebenszyklus der Coroutine repräsentiert. Ein Job kann sich in folgenden Zuständen befinden: New, Active, Completing, Completed, Cancelling, Cancelled. Jeder Zustand spiegelt den Ausführungsstatus wider und ermöglicht Reaktionen auf Änderungen.

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

println("Job ist aktiv: ${job.isActive}")
delay(2500L)
job.cancel()
println("Job ist gecancelt: ${job.isCancelled}")

Job unterstützt eine Hierarchie: Wenn eine Eltern-Coroutine gecancelt wird, werden alle Kind-Coroutinen automatisch gecancelt. SupervisorJob ändert dieses Verhalten — Kind-Coroutinen werden nicht gecancelt, wenn eine von ihnen fehlschlägt.

Strukturierte Nebenläufigkeit in launch

Strukturierte Nebenläufigkeit bedeutet, dass jede Coroutine innerhalb eines bestimmten CoroutineScope gestartet wird und der Scope erst abgeschlossen wird, wenn alle Kind-Coroutinen ihre Arbeit beendet haben. launch unterstützt dieses Prinzip vollständig — Coroutinen, die innerhalb einer anderen Coroutine gestartet werden, sind deren Kinder.

Verschachtelte launch-Aufrufe

Bei verschachtelten launch-Aufrufen entsteht ein Coroutine-Baum. Die Eltern-Coroutine wartet auf die Fertigstellung aller Kinder, was eine vorhersagbare Ausführungsreihenfolge garantiert und die Ressourcenverwaltung vereinfacht.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Kind 1 abgeschlossen")
        }
        launch {
            delay(500L)
            println("Kind 2 abgeschlossen")
        }
        println("Alle Kinder abschlossen vor dieser Zeile")
    }
}

Dieses Verhalten unterscheidet sich von der thread-basierten Nebenläufigkeit, bei der Kind-Threads nicht an den Eltern-Thread gebunden sind. Bei Coroutinen wird die Eltern-Coroutine nicht abgeschlossen, bis alle Kinder ihre Arbeit beendet haben.

Ausnahmebehandlung in launch

Die Ausnahmebehandlung in launch hängt vom Job-Typ ab. Bei einem normalen Job propagieren Ausnahmen an die Eltern-Coroutine und canceln sie. Bei SupervisorJob oder SupervisorScope werden Ausnahmen isoliert — ein Fehler in einer Kind-Coroutine wirkt sich nicht auf die anderen aus.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Gefangen: ${e.message}")
    }
}
scope.launch {
    println("Dies läuft dank SupervisorJob weiter")
}

Zur globalen Behandlung von nicht abgefangenen Ausnahmen wird CoroutineExceptionHandler verwendet. Er fängt Ausnahmen, die innerhalb der Coroutine nicht behandelt wurden, und ermöglicht die Protokollierung des Fehlers, ohne die Anwendung zum Absturz zu bringen.

Anwendungsbeispiele von launch in Android

In Android wird launch überall eingesetzt: von ViewModel bis WorkManager. Das Hauptmuster ist die Verwendung von lifecycleScope im Fragment und viewModelScope im ViewModel zur automatischen Cancellation von Coroutinen bei Beendigung des Komponentenlebenszyklus.

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 cancelt Coroutinen automatisch, wenn das ViewModel zerstört wird. Dies verhindert Speicherlecks und stellt sicher, dass Hintergrundoperationen nach dem Verlust des Kontexts nicht fortgesetzt werden. Zusätzlich kann withContext zum Wechseln zwischen Dispatchern verwendet werden.