Recomposed
Coroutines

Kotlin Flow: Ein mentales Modell

Oct 25, 2026 · 10 min read

Kotlin Flow: Ein mentales Modell

Die Intuition

Kotlin Flow ist Kotlins Version von : Ein emittiert Werte, ein Consumer sammelt sie ein. flow { } liest sich wie die Beschreibung eines Producers, der bereits da draußen läuft, und collect { } zapft diesen nur als Consumer an. Das ist das Bild, das man von einer List oder einem Event-Bus übernimmt – und es ist auf eine bestimmte Weise falsch.

  • Der Builder-Block eines ist der Producer, und er ist kein laufender Prozess, sondern ein Rezept. Nichts darin wird ausgeführt, bis ein Consumer ihn sammelt.
  • Der Aufruf von .collect() führt dieses Rezept von vorne aus und erzeugt Werte nur für diesen einen Consumer. Ein zweiter .collect() auf demselben Flow führt den Producer erneut aus, von Grund auf, unabhängig davon.
  • Zwei Consumer teilen sich nicht einen Strom von Werten. Jeder erhält seinen eigenen Producer, von Grund auf ausgeführt, als wäre der Flow noch nie zuvor gesammelt worden.

Deshalb feuert ein Netzwerkaufruf oder eine Log-Zeile innerhalb eines flow { } einmal pro Collector, nicht einmal insgesamt – der mit Abstand häufigste "Moment, warum lief das zweimal?"-Bug-Report, den Flow produziert.

Standardmäßig kalt: Der Builder läuft pro Collector erneut

val userRequests = flow {
    println("Starting network call")
    emit(api.fetchUser())
}
 
userRequests.collect { println("Collector A got $it") }
userRequests.collect { println("Collector B got $it") }
Starting network call
Collector A got User(...)
Starting network call
Collector B got User(...)

"Starting network call" wird zweimal ausgegeben, nicht einmal. userRequests ist kein Wert, der ein Ergebnis hält, sondern ein Flow-Objekt, das ein Rezept hält. Jeder .collect()-Aufruf ist ein frischer Aufruf dieses Rezepts, mit seinem eigenen api.fetchUser()-Aufruf und seiner eigenen Emission, völlig ahnungslos, dass der andere Collector existiert.

Derselbe Bug, in einer realistischeren Form

Das Spielzeugbeispiel oben wirkt offensichtlich falsch, weil das println es verrät. Derselbe Mechanismus verursacht echte Duplicate-Network-Call-Bugs, wenn der Flow eine oder zwei Ebenen tiefer vergraben ist:

// ❌ Repository legt einen kalten Flow direkt frei
class UserRepository {
    fun observeUser(id: String): Flow<User> = flow {
        emit(api.fetchUser(id)) // wird für jeden Collector erneut ausgeführt
    }
}
 
// Zwei Composables, die jeweils den Flow derselben Aufrufstelle sammeln,
// lösen jeweils ihren eigenen unabhängigen api.fetchUser(id)-Aufruf aus
@Composable
fun ProfileHeader(repo: UserRepository, id: String) {
    val user by repo.observeUser(id).collectAsState(initial = null)
    // ...
}
 
@Composable
fun ProfileDetails(repo: UserRepository, id: String) {
    val user by repo.observeUser(id).collectAsState(initial = null)
    // ...
}

Auf den ersten Blick sieht hier nichts nach einem Bug aus. observeUser(id) liest sich wie "gib mir den aktuellen Nutzer" – dieselbe Form wie ein Getter. Tatsächlich bedeutet es "gib mir ein Rezept, um den Nutzer abzurufen", und zwei Aufrufer bedeuten zwei laufende Rezepte, zwei Netzwerkaufrufe, für das, was wie ein einziges Stück State aussieht.

Das Fundamentale

Dies ist die Semantik von kalten vs. heißen Streams. Der Producer eines kalten Streams leistet keine Arbeit, bis ein Consumer sich anmeldet, und jede Anmeldung erhält ihren eigenen, unabhängigen Producer, von Anfang bis Ende. Der Producer eines heißen Streams läuft bereits (oder hält bereits einen aktuellen Wert), unabhängig von einem bestimmten Consumer, und jeder Consumer zapft denselben laufenden Producer an, statt einen neuen zu starten.

Kotlin Flow ist standardmäßig kalt. StateFlow und SharedFlow sind die bewusste heiße Ausnahme, die unten behandelt wird.

Anderswo: dasselbe Fundamentale, anderes Framework

  • RxJava/RxKotlin: Observable.create { } ist auf dieselbe Weise kalt, jedes subscribe() führt den gesamten Emitter-Block erneut aus. PublishSubject und BehaviorSubject sind die heißen Notausgänge – ein laufendes Rohr, das Subscriber anzapfen, statt es neu zu starten.
  • Combine (Swift/SwiftUI): Ein einfacher Publisher ist kalt und führt seinen Upstream für jeden neuen Subscriber erneut aus, sofern man nicht .share() oder .multicast() einfügt. CurrentValueSubject und PassthroughSubject sind Combines heiße Primitive, und CurrentValueSubject entspricht fast genau StateFlow: Beide halten immer einen aktuellen Wert und geben ihn sofort an jeden neuen Subscriber weiter.
  • JavaScript-Async-Generatoren / ReadableStream: Kalt nach derselben Regel – die Generator-Funktion ein zweites Mal aufzurufen (oder den Stream erneut zu durchlaufen) führt ihn von Anfang an erneut aus. Ein EventTarget/EventEmitter ist heiß: Er feuert unabhängig davon, ob etwas zuhört, und späte Listener verpassen einfach, was bereits passiert ist.
  • Androids altes LiveData: Heiß von Natur aus – es gibt kein Äquivalent zu einem kalten Builder-Block, jeder Observer hängt sich an denselben, bereits lebenden Werthalter. Das ist einer der Gründe, warum die Migration von LiveData zu Flow Probleme bereitet: Das mentale Modell, das man sich für LiveData aufgebaut hat, setzt heiße Semantik voraus, die ein einfaches flow { } nicht hat.

Die heiße Ausnahme: StateFlow und SharedFlow

StateFlow und SharedFlow führen keinen Builder pro Collector erneut aus, weil es keinen Builder gibt, den man erneut ausführen könnte. Etwas ruft genau einmal, von einer Stelle aus, MutableStateFlow.value = x oder MutableSharedFlow.emit(x) auf, und jeder Collector beobachtet denselben einzigen Strom von Updates.

class UserViewModel(private val repo: UserRepository) : ViewModel() {
    private val _uiState = MutableStateFlow<User?>(null)
    val uiState: StateFlow<User?> = _uiState.asStateFlow()
 
    init {
        viewModelScope.launch {
            _uiState.value = repo.observeUser(id).first() // läuft einmal, hier
        }
    }
}

Jeder Screen, der uiState sammelt, sieht denselben Wert, aktualisiert zu denselben Zeitpunkten, weil es genau einen Producer gibt (viewModelScope.launch oben), und uiState nur ein Fenster auf dessen aktuellen Wert ist. Das ist die ganze Sache mit StateFlow: Er ist konflationiert (neue Collector erhalten sofort den neuesten Wert, nicht ein Replay aller vergangenen) und er schließt niemals von selbst ab.

SharedFlow ist die allgemeinere Version: eine konfigurierbare replay-Anzahl statt StateFlows festem "immer genau der neueste Wert", und keine Voraussetzung, überhaupt einen aktuellen Wert zu halten. StateFlow ist ein SharedFlow mit replay = 1 und einem Initialwert.

Einen kalten Flow absichtlich in einen heißen verwandeln: stateIn/shareIn

Der Repository-Bug von vorher hat einen echten Fix, und der lautet nicht "verwende kein Flow", sondern "teile den, der kalt ist":

class UserViewModel(repo: UserRepository, id: String) : ViewModel() {
    val user: StateFlow<User?> = repo.observeUser(id)
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5_000),
            initialValue = null,
        )
}

stateIn führt das kalte Rezept von observeUser(id) genau einmal aus, innerhalb von viewModelScope, und stellt das Ergebnis als StateFlow bereit, das sich jeder Collector teilt. ProfileHeader und ProfileDetails aus dem vorherigen Beispiel würden jetzt denselben user sammeln, mit genau einem api.fetchUser(id)-Aufruf hinter beiden.

SharingStarted.WhileSubscribed(5_000) ist das Detail, das entscheidet, wann der geteilte Producer tatsächlich läuft: starten, sobald der erste Collector auftaucht, am Leben halten für 5 Sekunden nach dem Verlassen des letzten Collectors (damit eine schnelle Konfigurationsänderungs-Rotation ihn nicht neu startet), dann stoppen und abbauen, wenn niemand mehr zuhört. Eagerly startet ihn sofort und stoppt nie; Lazily startet beim ersten Collector, stoppt aber nie, sobald er einmal gestartet ist. In jedem Fall dieselbe Kalt-zu-Heiß-Umwandlung, nur eine andere Antwort auf die Frage "wann beginnt und endet der geteilte Durchlauf?".

Gängige Operatoren im Überblick

Keiner davon ändert die oben genannte Standardmäßig-kalt-Regel, sie sind nur ausgefeiltere Rezepte. Einen kalten Flow in combine oder flatMapLatest einzuwickeln macht ihn nicht heiß – der kombinierte/gemappte Flow führt seine gesamte Kette weiterhin pro Collector erneut aus, sofern nicht etwas ihn mit stateIn/shareIn teilt.

unten ist genau diese Frage: Was ein Flow tut, wenn der Producer schneller ist als der Collector, da "ewig warten" nicht immer die richtige Antwort ist.

OperatorKategorieWas er tut
map / filterTransformierenFormt Emissionen einzeln um oder verwirft sie, genauso wie Sequence/List
combineMehrere Flows kombinierenBerechnet aus dem neuesten Wert jeder Quelle neu, wann immer eine von ihnen emittiert
zipMehrere Flows kombinierenPaart die n-te Emission jeder Quelle; wartet, bis jede Seite emittiert hat, bevor ein Paar erzeugt wird
mergeMehrere Flows kombinierenVerschachtelt Emissionen mehrerer Quellen zu einer, in der Reihenfolge, in der sie eintreffen
flatMapLatestZu einem neuen Flow wechselnBricht den vorherigen inneren Flow ab und wechselt zu einem neuen, jedes Mal wenn der äußere Flow emittiert
flatMapConcatZu einem neuen Flow wechselnFührt innere Flows einen nach dem anderen aus, in Reihenfolge, nie überlappend
flatMapMergeZu einem neuen Flow wechselnFührt innere Flows gleichzeitig aus und verschachtelt ihre Emissionen
debounceRate LimitingVerwirft Emissionen, bis eine ruhige Lücke verstreicht, dann emittiert nur die neueste
distinctUntilChangedRate LimitingVerwirft eine neue Emission, wenn sie gleich der letzten tatsächlich emittierten ist
bufferBackpressureLässt den Producer einem langsamen Collector in einen Puffer fester Größe vorauslaufen, statt ihn sofort zu suspendieren; onBufferOverflow entscheidet, was passiert, sobald dieser Puffer voll ist
conflateBackpressureKurzform für buffer(capacity = 0, onBufferOverflow = BufferOverflow.DROP_OLDEST): kein echter Puffer, sondern immer den neuesten Wert behalten und verwerfen, was der Collector noch nicht erreicht hat
catchFehlerbehandlungFängt eine Upstream-Exception ab, ohne den Collector abzubrechen

buffer ist der Regler, von dem conflate eine fest eingestellte Variante ist: buffer(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST) hält einen ausstehenden Wert und verwirft den vorherigen, sobald ein neuer Wert eintrifft – genau das, was conflate() unter einem kürzeren Namen tut. Greife direkt zu buffer, wenn du ein größeres Fenster als einen Wert möchtest, oder zu BufferOverflow.DROP_LATEST/SUSPEND statt den ältesten zu verwerfen.

combine ist der Operator, der in der Praxis am häufigsten einen Cold-Rerun-Bug verbirgt:

// ❌ combine wickelt zwei kalte Flows ein; beide führen weiterhin ihr eigenes Rezept
// pro Collector erneut aus, also bedeuten zwei Screens, die dieselben zwei Repository-
// Flows kombinieren, VIER zugrunde liegende Abrufe, nicht zwei
val summary = combine(repo.observeUser(id), repo.observeOrders(id)) { user, orders ->
    Summary(user, orders)
}
 
// ✅ teile das kombinierte Ergebnis einmal, sodass jeder Collector
// denselben einzigen combine-Durchlauf anzapft, statt einen eigenen zu starten
val summary = combine(repo.observeUser(id), repo.observeOrders(id)) { user, orders ->
    Summary(user, orders)
}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)

Häufige Fehler

catch sieht nur Exceptions, die oberhalb von ihm in der Kette geworfen werden

flow {
    emit(1)
    throw RuntimeException("boom")
}
.catch { e -> emit(-1) } // ✅ fängt den Throw oben ab, da catch darunter sitzt
.map { value ->
    if (value == 1) throw RuntimeException("boom downstream")
    value
}
.collect { println(it) }
// Stürzt trotzdem ab: Der zweite Throw passiert *nach* catch in der Kette,
// daher sieht catch ihn nie. catch ist nur ein weiteres kaltes Glied im Rezept,
// kein globaler try/catch um die gesamte Collection.

Man greift zu catch in der Erwartung, dass es sich wie ein umgebender try/catch-Block verhält und alles überall in der Pipeline abfängt. Das tut es nicht. catch ist ein gewöhnliches Glied in derselben kalten Kette wie map/filter, also fängt es nur eine Exception ab, die von etwas Upstream davon geworfen wird (näher am flow { }-Builder), niemals etwas, das von einem danach platzierten Operator geworfen wird. Platziere catch als letztes Glied vor collect, wenn es alles darüber sehen soll.

Das Emittieren aus dem falschen CoroutineContext stürzt mit "Flow invariant is violated" ab

// ❌ withContext innerhalb des Builders ändert den Context, in dem emit() läuft,
// was die Context-Preservation-Garantie von Flow bricht
flow {
    withContext(Dispatchers.IO) {
        emit(api.fetchUser()) // IllegalStateException zur Laufzeit
    }
}
 
// ✅ flowOn verschiebt die Upstream-Arbeit auf IO, ohne dass emit() jemals
// in einem anderen Context läuft als dem, in dem flow { } erstellt wurde
flow {
    emit(api.fetchUser())
}.flowOn(Dispatchers.IO)

Ein flow { }-Builder garantiert, dass emit() immer in demselben CoroutineContext läuft, in dem sich der Collector befindet, sodass ein Collector darauf vertrauen kann, dass nichts, was er sammelt, mitten im Stream heimlich auf einen anderen Dispatcher gewechselt ist. withContext um emit() selbst herum aufzurufen bricht diese Garantie und führt zu einem Absturz. flowOn ist das richtige Werkzeug: Es verschiebt alles upstream davon auf den angegebenen Dispatcher, während das Context-Preservation-Versprechen von emit() für denjenigen, der es sammelt, intakt bleibt.

StateFlow emittiert einen Wert nicht erneut, der strukturell gleich dem aktuellen ist

data class UiState(val items: List<Item>)
 
val _state = MutableStateFlow(UiState(items = mutableListOf()))
 
// ❌ verändert dieselbe Liste vor Ort und weist dann dieselbe
// Referenz erneut zu: strukturell gleich dem alten Wert, also emittiert nichts
_state.value.items as MutableList
(_state.value.items as MutableList).add(newItem)
_state.value = _state.value // No-op, Collector sehen newItem nie
 
// ✅ ein wirklich neuer Wert, also sieht equals() einen Unterschied und emittiert
_state.value = _state.value.copy(items = _state.value.items + newItem)

StateFlow ist konflationiert: Das Zuweisen von .value emittiert nur an Collector, wenn der neue Wert nicht equals() zum aktuellen ist. Eine gehaltene Collection vor Ort zu verändern und dieselbe Referenz erneut zuzuweisen sieht nach einem Update aus, ist es aber nicht, soweit StateFlow erkennen kann, da sich an der Referenz tatsächlich nichts geändert hat. Das ist derselbe Grund, warum unveränderliche Datenklassen und copy() die Konvention rund um StateFlow sind – keine Stilpräferenz.

awaitClose zu vergessen lässt callbackFlow sofort abstürzen

existiert genau für die APIs, die ein einfaches flow { } nicht ausdrücken kann: etwas, das einem Werte über einen Callback/Listener übergibt, statt direkt emit() zuzulassen, wie ein Location-Provider oder der Click-Listener einer View. Es ist darunter immer noch ein kalter Flow, auf dieselbe flow { }-förmige Weise aufgebaut, nur mit einem registrierten Callback, der für die Emissionen steht.

// ❌ der Block kehrt direkt nach der Registrierung des Callbacks zurück, ohne
// Suspension Point: callbackFlow behandelt das als Bug und wirft eine Exception
fun locationUpdates(client: LocationClient): Flow<Location> = callbackFlow {
    val callback = object : LocationCallback() {
        override fun onLocationResult(result: LocationResult) {
            trySend(result.lastLocation)
        }
    }
    client.requestLocationUpdates(callback)
    // IllegalStateException: callbackFlow-Block wurde beendet, aber der
    // Channel wurde nie geschlossen, also bleibt kein deterministischer Moment
    // übrig, um den Callback oben abzumelden
}
 
// ✅ awaitClose suspendiert, bis der Collector abbricht (oder der Channel
// anderweitig geschlossen wird), was auch die einzige sichere Stelle ist,
// um den Callback abzumelden
fun locationUpdates(client: LocationClient): Flow<Location> = callbackFlow {
    val callback = object : LocationCallback() {
        override fun onLocationResult(result: LocationResult) {
            trySend(result.lastLocation)
        }
    }
    client.requestLocationUpdates(callback)
    awaitClose { client.removeLocationUpdates(callback) }
}

Der gesamte Vertrag von callbackFlow ist um einen deterministischen Moment herum aufgebaut, um aufzuräumen, was auch immer es als Callback registriert hat. Wenn der Block von selbst zurückkehren kann, gibt es keinen solchen Moment, der Callback würde einfach durchsickern, unwiderruflich registriert, ohne dass noch etwas ihn abmelden könnte. Also erzwingt callbackFlow den Vertrag zur Laufzeit: Der Block muss in einem Suspension Point enden, fast immer awaitClose { }, oder er wirft eine Exception, statt stillschweigend zu lecken.

callbackFlow ist auch kalt, was bedeutet, dass sich der Callback pro Collector erneut registriert

fun locationUpdates(client: LocationClient): Flow<Location> = callbackFlow {
    val callback = object : LocationCallback() {
        override fun onLocationResult(result: LocationResult) {
            trySend(result.lastLocation)
        }
    }
    client.requestLocationUpdates(callback) // wird pro Collector erneut registriert
    awaitClose { client.removeLocationUpdates(callback) }
}

Einen Callback in callbackFlow einzuwickeln befreit ihn nicht vom Standardmäßig-kalt-Prinzip, er ist immer noch aus demselben flow { }-förmigen Rezept aufgebaut. Zwei Collector registrieren zwei separate Location-Listener beim OS, jeder unabhängig abgebaut, wenn sein eigener Collector abgebrochen wird. Der Fix ist derselbe wie oben: shareIn einmal in einem Scope, der jeden einzelnen Collector überlebt, statt jeden Screen, der Standortdaten möchte, locationUpdates() selbst aufrufen zu lassen.

Flow hat kein .value, StateFlow hat eines – und das eine zu greifen, wenn man das andere meinte, ist ein Typfehler, der nur darauf wartet, zu passieren

Ein einfacher Flow<T> kann nicht synchron gelesen werden, es gibt keinen aktuellen Wert zu lesen, da nichts läuft, bis man ihn sammelt. StateFlow<T> hat immer einen. Code, der generisch einen Flow<T>-Parameter annimmt, aber tatsächlich .value benötigt, ist ein Zeichen dafür, dass die Funktion stillschweigend heiße Semantik vorausgesetzt hat, die nie garantiert war.

Ein Flow ist ein Rezept, keine Leitung, die bereits Werte trägt: standardmäßig kalt, jeder collect() führt seine eigene unabhängige Kopie erneut aus, und StateFlow/SharedFlow (oder stateIn/shareIn auf einem kalten Flow) sind das bewusste Opt-in, ihn einmal auszuführen und alle das Ergebnis teilen zu lassen.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach