Recomposed
Coroutines

Der Coroutine-Baum: Was Scope, Job und Cancellation wirklich bedeuten

Oct 21, 2026 · 11 min read

Der Coroutine-Baum: Was Scope, Job und Cancellation wirklich bedeuten

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.

FIG. 01
launch and async don't spawn independent tasks, they each add a child Job as a new branch under the Job that called them

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.

FIG. 02
loadUser suspends at fetchToken, freeing the thread, and resumes via its Continuation once the token arrives

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.

FIG. 03
Two ways awaitLocation can end: the listener fires first, or the parent cancels first and invokeOnCancellation tears the listener down instead

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.

0 queued · 0 suspended · 1 thread
Speed
Dispatcher threadidle

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 TaskGroup gestarteter Task ist auf dieselbe Weise ein Kind dieser Gruppe. Bricht man den Eltern-Task ab, springt Task.isCancelled im 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 in asyncio zu bringen, das zuvor erlaubte, asyncio.create_task() ganz ohne Elternknoten aufzurufen – genau das GlobalScope-Problem von oben.
  • Go hat im Gegensatz dazu keine Primitive für structured concurrency in der Sprache. Ein nacktes go func() {}() ist standardmäßig wie GlobalScope.launch: nichts verfolgt es, nichts bricht es automatisch ab. errgroup und context.Context existieren eigens als nachgerüstete Lösung dafür, keinen eingebauten Baum zu haben.
  • Node/TypeScript fällt in dieselbe Kategorie wie Go. Ein Promise hat überhaupt keine eingebaute Cancellation, und Promise.all lehnt ab, sobald ein einziges Promise ablehnt, ohne die anderen abzubrechen. Sie laufen unbeobachtet weiter. AbortController/AbortSignal ist das nächste Analogon zu einem Job, 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-TypErzeugt durchBricht Geschwister bei Fehler ab?Typischer Einsatz
JobStandard bei launch/async, coroutineScope { }JaStandard-structured-concurrency: "wenn ein Teil fehlschlägt, stoppe die gesamte Operation"
SupervisorJobSupervisorJob(), supervisorScope { }, viewModelScopeNein, nur für direkte KinderUnabhängige parallele Arbeit unter einem Scope: "wenn ein Teil fehlschlägt, soll der Rest weiterlaufen"
CompletableJobWas die Factory-Funktionen Job()/SupervisorJob() tatsächlich zurückgebenGleich wie die Basis, die es umhülltManuelles 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 forever

Die 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 CancellationException und behandelt sie als "dieser Zweig ist beendet, weil ihm das gesagt wurde", nicht als Fehler.
  • Sie wird nie an einen CoroutineExceptionHandler gemeldet.
  • 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 eines ViewModel oder LifecycleOwner gebunden sind, sodass man den Baum kostenlos bekommt, statt einen Job manuell 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, sodass doWork() keinen eigenen Job verwalten 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.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach