Was eine Coroutine wirklich ist
Eine Coroutine ist eine Arbeitseinheit, die mitten in ihrer Ausführung
pausieren und später fortsetzen kann, ohne den Thread zu blockieren, auf
dem sie läuft. Die Funktion, die pausieren kann, wird mit suspend
markiert.
Der Aufruf einer suspend-Funktion läuft nicht von Anfang bis Ende durch,
wie ein normaler Funktionsaufruf. An dem Punkt, an dem es noch nichts zu
tun gibt (Warten auf IO, ein delay(), eine andere Coroutine), gibt sie
die Kontrolle an den Dispatcher zurück. Sie wird genau an diesem Punkt
fortgesetzt, sobald das Ergebnis vorliegt.
Die Intuition
launch { } und async { } lesen sich wie "starte eine Hintergrundaufgabe
und mach weiter." Das ist das Bild, das die meisten Tutorials aufbauen,
und es ist auf eine bestimmte Art falsch: Es behandelt eine Coroutine als
frei schwebend, genauso wie man einen Thread startet und vergisst, dass
er existiert.
- Jede Coroutine startet innerhalb eines
CoroutineScope, und dieser Scope ist eine Grenze dafür, wie lange die Coroutine leben darf. - Jede Coroutine hat einen
Job, ein Objekt, das ihren Zustand und ihre Position in einem Baum aus Eltern- und Kind-Coroutines verfolgt. - Bricht man eine Elternkoroutine ab, wird jeder Nachkomme in diesem Baum ebenfalls abgebrochen. Nicht wegen irgendeiner speziellen rekursiven Abbruchschleife, sondern weil genau das die Natur des Baums ist.
Man sollte sich launch/async weniger als "starte eine Aufgabe"
vorstellen und mehr als "füge diesem Baum einen Zweig hinzu." Eine lange
Liste separat gemerkter Regeln (warum Cancellation kaskadiert, warum der
Absturz eines Kindes seine Geschwister mit sich reißen kann, warum
GlobalScope gefährlich ist) reduziert sich auf ein einziges Bild: den
Baum.
Jede Box hier ist ein Job. launch und async sind nur zwei
verschiedene Arten, einen hinzuzufügen, mit einem echten Unterschied:
launch gibt einem nur ein Handle zum Zweig selbst zurück, async gibt
einem ein Deferred zurück, das zusätzlich das irgendwann vorliegende
Ergebnis des Zweigs trägt. Bricht man Root ab, werden A, A1, B und
B1 alle mit abgebrochen, denn sie sind keine separaten Dinge, die man
einzeln aufspüren müsste, sie sind einfach der Teil dieses Baums
darunter.
Wie Suspension wirklich funktioniert: eine Zustandsmaschine
Der Kotlin-Compiler hat keine Laufzeitmagie, um eine Funktion mitten im
Aufruf zu pausieren. Er schreibt eine suspend-Funktion in eine
Zustandsmaschine um: Jeder Suspension-Punkt wird zu einem nummerierten
Zustand, und die lokalen Variablen der Funktion werden
in eine
verschoben, die sich merkt, wo fortgesetzt werden soll.
suspend fun loadUser(id: String): User {
val token = fetchToken() // state 0, suspends here
val profile = fetchProfile(token) // state 1, suspends here
return profile.toUser() // state 2, returns
}Der Aufruf von loadUser blockiert nichts, während auf fetchToken
gewartet wird. Er gibt eine Continuation zurück und übergibt die
Kontrolle an den Dispatcher. Wenn das Token eintrifft, ruft der
Dispatcher diese Continuation auf, die loadUser bei state 1 fortsetzt,
wobei token bereits aus dem gespeicherten Zustand wiederherstellt ist.
Das ist auch der Grund, warum Cancellation kooperativ ist, nicht sofort (dazu mehr weiter unten): Eine Coroutine kann nur an einem Suspension-Punkt unterbrochen werden, denn das ist der einzige Moment, in dem die Zustandsmaschine die Kontrolle an einen Scheduler zurückgibt, der überhaupt etwas prüfen kann.
Callback-basierte APIs in den Baum einbinden: suspendCancellableCoroutine
Nicht jeder Suspension-Punkt entsteht durch den Aufruf einer anderen
suspend-Funktion. Android ist voller Callback-basierter APIs
(ActivityResultCaller, Listener-artige SDKs, alles, was mit dem Aufruf
eines Callbacks endet, statt einen Wert zurückzugeben), die nichts von
Coroutines wissen. suspendCancellableCoroutine ist der Weg, eine davon
in einen echten Suspension-Punkt zu verwandeln, statt in einen
Seitenkanal, den der Baum nicht sehen kann.
suspend fun awaitLocation(): Location = suspendCancellableCoroutine { continuation ->
val listener = LocationListener { location -> continuation.resume(location) }
locationProvider.requestLocation(listener)
continuation.invokeOnCancellation {
locationProvider.removeListener(listener)
}
}Während die Zustandsmaschine oben ihre Continuation vom Compiler
generiert und verdrahtet bekommt, gibt dir suspendCancellableCoroutine
diese Continuation direkt in die Hand. Du hältst sie innerhalb der
Lambda fest, stößt die Callback-basierte API an und setzt sie manuell
fort, sobald der eigentliche Callback mit einem Ergebnis aufgerufen wird.
invokeOnCancellation ist der Teil, der das Ganze tatsächlich in den
Baum einbindet. Angenommen, der Scope, der awaitLocation() aufgerufen
hat, wird abgebrochen, während eine Standortanfrage noch ausstehend ist.
locationProvider weiß davon nichts und ruft listener einfach weiter
auf, bis ihm jemand sagt, er solle aufhören. Ohne invokeOnCancellation
lebt dieser Listener über den Punkt hinaus weiter, an dem die Coroutine,
die ihn erzeugt hat, längst nicht mehr existiert, ein Leck mit derselben
Form wie das GlobalScope-Leck weiter unten in diesem Beitrag. Der
Cancellation-Handler läuft genau dann, wenn der Elternknoten abbricht,
und entfernt den Listener, bevor er erneut aufgerufen werden kann.
Genau das lässt eine Callback-basierte API wie einen gewöhnlichen Knoten im Baum wirken statt wie eine Seitentür hinein: Cancellation kann von einem Elternknoten aus hineinreichen, genauso wie sie jeden vom Compiler erzeugten Suspension-Punkt erreicht.
Dispatcher: warum ein Thread viele Coroutines ausführt
Ein Job sagt, wie die Beziehung einer Coroutine zu anderen Coroutines
aussieht. Ein CoroutineDispatcher sagt, welcher Thread oder Thread-Pool
sie tatsächlich ausführt. Das sind zwei unterschiedliche Fragen, und sie
zu vermischen ist der Punkt, an dem die Intuition "ein Thread kann immer
nur eine Sache gleichzeitig tun" in die Irre führt.
- Eine suspendierte Coroutine belegt überhaupt keinen Thread. Sie ist eine Continuation, die auf dem Heap liegt und darauf wartet, fortgesetzt zu werden.
- Ein Dispatcher braucht einen Thread nur für die Momente, in denen eine Coroutine aktiv Code ausführt, nicht für die Momente, in denen sie suspendiert ist.
- Tausende Coroutines können gleichzeitig suspendiert sein, ohne dass dafür ein einziger Thread gebraucht wird. Nur die aktiv ausführenden brauchen jeweils einen Thread.
Deshalb sind Coroutines im Vergleich zu Threads günstig. Ein
Betriebssystem-Thread reserviert von vornherein seinen eigenen Call-Stack
(auf der JVM üblicherweise rund 1 MB), egal ob er beschäftigt oder im
Leerlauf ist. Eine suspendierte Coroutine ist nur ein Continuation-
Objekt, in der Regel ein paar Dutzend Bytes, das auf dem Heap parkt, bis
etwas sie fortsetzt.
Solid = holding the dispatcher thread. Faint = waiting its turn. Hollow = suspended, holding no thread at all. However many coroutines are running, only one is ever actually on the thread at once.
Das ist kein rein abstraktes Scheduling-Rätsel. Dasselbe Single-Thread-Interleaving ist genau das, was eine gewöhnliche Press-and-Hold-Button-Animation funktionieren lässt:
val scope = rememberCoroutineScope()
val scale = remember { Animatable(1f) }
Modifier.pointerInput(Unit) {
detectTapGestures(onPress = {
scope.launch { scale.animateTo(1.2f) } // queued, doesn't run inline
tryAwaitRelease() // suspends here, thread freed
scope.launch { scale.animateTo(1f) } // retargets the same Animatable
})
}scope.launch führt die Wachstumsanimation nicht inline aus, sondern
plant einen neuen Job auf dem Dispatcher von rememberCoroutineScope()
(dem UI-Thread) ein und kehrt sofort zurück. tryAwaitRelease()
suspendiert dann und gibt den Thread zurück, was genau das ist, was den
eigenen Suspension-Punkten der Wachstumsanimation (withFrameNanos,
Warten auf den nächsten Frame) überhaupt erst eine Chance gibt. Hier läuft
nichts parallel: Die onPress-Coroutine und die Animations-Coroutine
wechseln sich auf einem Thread ab, dasselbe Interleaving wie in der Demo
oben, nur mit einem Finger auf dem Bildschirm statt einem Button mit der
Aufschrift "Launch coroutine."
Wo der Baum leckt: GlobalScope
class UserViewModel : ViewModel() {
fun loadUser(id: String) {
// Leak: this coroutine's parent is GlobalScope, which never gets
// cancelled. It keeps running after the ViewModel is cleared,
// holding a reference to it the whole time.
GlobalScope.launch {
val user = repository.fetchUser(id)
_uiState.value = UiState.Loaded(user)
}
}
}class UserViewModel : ViewModel() {
fun loadUser(id: String) {
// Fixed: viewModelScope's Job is a child of this ViewModel's
// lifecycle. onCleared() cancels it, which cancels this launch
// too, because it's actually in the tree.
viewModelScope.launch {
val user = repository.fetchUser(id)
_uiState.value = UiState.Loaded(user)
}
}
}GlobalScope ist an nichts gebunden, und genau das ist das Problem. Er
hat keinen Elternknoten, also kann nichts im Lifecycle der App nach oben
greifen und ihn abbrechen.
launch vs. async: das Exception-Timing, das niemand richtig hinbekommt
Die gängige Behauptung lautet: "launch wirft sofort, async wartet, bis
man .await() aufruft." Das ist nur halb wahr, und die fehlende Hälfte
ist genau die, auf die es ankommt.
coroutineScope {
launch {
throw IllegalStateException("boom")
// Propagates immediately: cancels this scope's other children
// and rethrows once they've wound down.
}
}coroutineScope {
val deferred = async {
throw IllegalStateException("boom")
// Still propagates immediately through the parent job, same as
// launch above, because this async has a structured parent.
// await() is never even reached.
}
deferred.await()
}val deferred = GlobalScope.async {
throw IllegalStateException("boom")
// Only deferred here: this async has no structured parent to
// propagate to, so the exception just sits in the Deferred until
// something calls await() on it. Forget to call await(), and the
// exception disappears silently.
}Die Regel lautet nicht "launch vs. async." Sie lautet "hat diese
Coroutine einen Elternknoten im Baum." Eingebettet in einen Scope
propagieren beide auf dieselbe Weise: sofort, durch den Baum hindurch. Nur
bei einem nackten, elternlosen async zeigt sich das
"Warten-auf-.await()"-Verhalten, und das hat dieselbe Grundursache wie
das GlobalScope-Leak oben: kein Elternknoten bedeutet, dass nichts
automatisch propagiert.
Das Fundamentale
Das ist structured concurrency: Jede Coroutine hat einen Elternknoten,
gebunden an einen CoroutineScope, der ihre Lebensdauer definiert. Ein
Job ist nicht nur ein Handle, er ist die Position der Coroutine in
diesem Baum. Cancellation fließt den Baum hinab (bricht man einen
Elternknoten ab, bricht jeder Nachkomme ab), und Fehler fließen ihn hinauf
(ein unbehandelter Fehler eines Kindes bricht seine Geschwister ab und
propagiert zum Elternknoten), sofern nicht jemand absichtlich eine dieser
Kanten durchtrennt.
Anderswo: dasselbe Fundamentale, anderes Framework
- Swifts structured concurrency: Ein in einer
TaskGroupgestarteterTaskist auf dieselbe Weise ein Kind dieser Gruppe. Bricht man den Eltern-Taskab, springtTask.isCancelledim gesamten Baum auf true, und die Kinder einer Gruppe werden abgebrochen, wenn eines von ihnen eine Exception wirft – dieselbe Propagationsform wie oben. - Pythons Trio: Hier wurde der Begriff "structured concurrency" buchstäblich
geprägt. Trios
ist der Scope. Man kann keinen Task starten, ohne eine zu haben, und der
nursery-Block beendet sich erst, wenn jedes von ihm gestartete Kind
fertig ist – dieselbe Idee einer Lebensdauer-Grenze wie bei einem
CoroutineScope. - Pythons
asyncio.TaskGroup(3.11+): wurde eigens hinzugefügt, um Trios strukturiertes Modell inasynciozu bringen, das zuvor erlaubte,asyncio.create_task()ganz ohne Elternknoten aufzurufen – genau dasGlobalScope-Problem von oben. - Go hat im Gegensatz dazu keine Primitive für structured concurrency
in der Sprache. Ein nacktes
go func() {}()ist standardmäßig wieGlobalScope.launch: nichts verfolgt es, nichts bricht es automatisch ab.errgroupundcontext.Contextexistieren eigens als nachgerüstete Lösung dafür, keinen eingebauten Baum zu haben. - Node/TypeScript fällt in dieselbe Kategorie wie Go. Ein
Promisehat überhaupt keine eingebaute Cancellation, undPromise.alllehnt ab, sobald ein einziges Promise ablehnt, ohne die anderen abzubrechen. Sie laufen unbeobachtet weiter.AbortController/AbortSignalist das nächste Analogon zu einemJob, aber es ist manuell: Man erzeugt ein Signal und gibt es explizit an das weiter, was sich entscheidet, es zu prüfen. Nichts propagiert es oder baut automatisch einen Baum daraus.
Job-Typen
Job ist kein festes Verhalten, sondern ein Interface mit Varianten, die
jeweils eine Regel ändern, wie der Baum Fehler propagiert oder manuelle
Kontrolle offenlegt. Die Baumstruktur (Eltern/Kind, Cancellation fließt
nach unten) bleibt bei allen gleich.
| Job-Typ | Erzeugt durch | Bricht Geschwister bei Fehler ab? | Typischer Einsatz |
|---|---|---|---|
Job | Standard bei launch/async, coroutineScope { } | Ja | Standard-structured-concurrency: "wenn ein Teil fehlschlägt, stoppe die gesamte Operation" |
SupervisorJob | SupervisorJob(), supervisorScope { }, viewModelScope | Nein, nur für direkte Kinder | Unabhängige parallele Arbeit unter einem Scope: "wenn ein Teil fehlschlägt, soll der Rest weiterlaufen" |
CompletableJob | Was die Factory-Funktionen Job()/SupervisorJob() tatsächlich zurückgeben | Gleich wie die Basis, die es umhüllt | Manuelles Markieren eines Jobs als abgeschlossen via complete()/completeExceptionally(), orthogonal zur Supervisor-Unterscheidung |
Die Spalte "nur direkte Kinder" ist das Detail, über das die meisten
stolpern: Der Schutz eines SupervisorJob reicht nicht über seine
unmittelbaren Kinder hinaus. Startet eines dieser Kinder mit launch
eigene Enkelkinder, propagiert der Fehler eines Enkelkinds trotzdem
normal zu seinem unmittelbaren Elternknoten (dem direkten Kind) hoch und
bricht den eigenen Unterzweig dieses Kindes ab. Der Supervisor verhindert
nur, dass der Fehler über sich selbst hinaus nach oben klettert.
Randfälle
Cancellation ist kooperativ, nicht sofort
Der Aufruf von job.cancel() unterbricht Code nicht mitten in einer
Anweisung, so wie das Töten eines Threads es tun würde. Er setzt ein Flag,
das an Suspension-Punkten geprüft wird, und genau deshalb läuft eine
busy loop ohne delay(), ohne yield(), ohne einen suspendierenden
Aufruf darin, einfach weiter, nachdem sie "abgebrochen" wurde:
val job = launch {
while (true) {
// No suspension point in this loop: isActive never gets checked
// automatically, so cancel() has nothing to interrupt.
computeSomething()
}
}
job.cancel() // the loop above keeps running foreverDie Lösung besteht darin, innerhalb der Schleife isActive zu prüfen
oder ensureActive() aufzurufen. Das gibt der Cancellation einen Punkt,
an dem sie tatsächlich wirken kann.
CancellationException propagiert nicht als Fehler
val job = launch {
try {
doWork()
} catch (e: Exception) {
log.error("doWork failed", e) // also catches CancellationException
}
}
job.cancel()
// doWork() keeps running past the catch block: cancel() threw
// CancellationException to unwind the coroutine, but this catch
// swallowed it like any other Exception, so nothing actually stops.Der Abbruch einer Coroutine setzt nicht einfach nur ein Flag. Er wirft an
dem aktuellen Suspension-Punkt der Coroutine eine
CancellationException – genau den Mechanismus, den auch ein echter
Fehler verwendet, um den Call-Stack abzuwickeln.
Der Unterschied liegt darin, was passiert, sobald diese Exception beim
Job ankommt:
- Die Coroutine-Maschinerie prüft gezielt auf
CancellationExceptionund behandelt sie als "dieser Zweig ist beendet, weil ihm das gesagt wurde", nicht als Fehler. - Sie wird nie an einen
CoroutineExceptionHandlergemeldet. - Anders als die Fehler im
launch/async-Abschnitt oben bricht sie nicht die Geschwister ab und propagiert nicht als Fehler zum Elternknoten.
Deshalb ist ein breites Abfangen von Exception innerhalb einer
Coroutine ein echter Bug, kein bloßer Stilfehler. CancellationException
ist ein Subtyp von Exception, also verschluckt ein pauschaler Catch sie
zusammen mit allem anderen, und die Coroutine läuft weiter, nachdem sie
angeblich abgebrochen wurde.
Die Lösung ist, einen engeren Typ abzufangen oder erneut zu werfen, wenn
die abgefangene Exception eine CancellationException ist:
val job = launch {
try {
doWork()
} catch (e: CancellationException) {
throw e // let cancellation keep propagating
} catch (e: Exception) {
log.error("doWork failed", e)
}
}
job.cancel()
// The CancellationException branch rethrows immediately, so cancellation
// still unwinds the coroutine. A real failure from doWork() still falls
// through to the logging branch below it, same as before.withContext fügt keinen Zweig hinzu
withContext nimmt ein suspendierendes Lambda entgegen, genau wie
launch/async, was es verlockend macht, es ebenfalls als Start eines
neuen Zweigs zu lesen. Das ist es nicht.
suspend fun loadUser(id: String): User {
val user = withContext(Dispatchers.IO) {
repository.fetchUserBlocking(id) // runs on IO, caller suspends here
}
// Reached only once the block above finishes. Same coroutine, same
// Job as loadUser itself, just back on the original dispatcher.
log.info("loaded $user")
return user
}withContext gibt weder ein Job noch ein Deferred zurück, nichts, an
dem man festhalten könnte. Es suspendiert die aufrufende Coroutine,
wechselt für die Dauer des Blocks den Dispatcher (oder welches
Context-Element man auch übergeben hat), und setzt mit dem Ergebnis
fort, sobald dieser Block fertig ist. Nichts läuft parallel zur
Aufrufstelle, es gibt keinen zweiten Zweig zu verfolgen, es ist die
ganze Zeit derselbe Knoten im Baum. Bricht man die Elternkoroutine ab,
während eine Coroutine in einem withContext-Block steckt, wird dieser
Block genau wie jeder andere Suspension-Punkt mit abgebrochen, weil er
von Anfang an kein eigenständiger Knoten war.
runBlocking ist eine Brücke, kein Baummitglied
Wie withContext oben fügt auch runBlocking einem bestehenden Baum
keinen Zweig hinzu, aber aus dem entgegengesetzten Grund: Es passt nicht
in das übliche Bild, weil es das gar nicht soll. Es existiert, um
suspendierenden Code aus nicht-suspendierendem
Code aufzurufen (main(), ein JVM-Test, ein Callback, der selbst keine
Coroutine ist), und es tut das, indem es den aufrufenden Thread blockiert,
bis sein Coroutine-Body fertig ist. Verschachtelt man runBlocking
irgendwo tief im Produktions-Android-Code, hat man genau das
Thread-Blocking wieder eingeführt, das der Rest dieses Systems vermeiden
soll.
Einsatz in der Praxis
viewModelScope/lifecycleScope: Androids vorgefertigte Scopes, die an die Lebensdauer einesViewModeloderLifecycleOwnergebunden sind, sodass man den Baum kostenlos bekommt, statt einenJobmanuell zu verwalten.- Flow-Collection:
flow.collect { }läuft innerhalb des Scopes, der es aufgerufen hat, sodass das Abbrechen dieses Scopes auch das Collecting stoppt – derselbe Baum. - WorkManagers
CoroutineWorker: Die Bibliothek besitzt einen Scope pro Arbeitsanfrage und bricht ihn ab, wenn die Arbeit abgebrochen wird oder ein Timeout eintritt, sodassdoWork()keinen eigenenJobverwalten muss.
Eine Coroutine schwebt nie frei. Sie ist immer ein Knoten in einem Baum, und der Baum, nicht die Coroutine selbst, ist das, was man tatsächlich verwaltet.



