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 demselbenFlowfü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
Flownoch 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, jedessubscribe()führt den gesamten Emitter-Block erneut aus.PublishSubjectundBehaviorSubjectsind die heißen Notausgänge – ein laufendes Rohr, das Subscriber anzapfen, statt es neu zu starten. - Combine (Swift/SwiftUI): Ein einfacher
Publisherist kalt und führt seinen Upstream für jeden neuen Subscriber erneut aus, sofern man nicht.share()oder.multicast()einfügt.CurrentValueSubjectundPassthroughSubjectsind Combines heiße Primitive, undCurrentValueSubjectentspricht fast genauStateFlow: 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. EinEventTarget/EventEmitterist 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 vonLiveDatazu Flow Probleme bereitet: Das mentale Modell, das man sich fürLiveDataaufgebaut hat, setzt heiße Semantik voraus, die ein einfachesflow { }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.
| Operator | Kategorie | Was er tut |
|---|---|---|
map / filter | Transformieren | Formt Emissionen einzeln um oder verwirft sie, genauso wie Sequence/List |
combine | Mehrere Flows kombinieren | Berechnet aus dem neuesten Wert jeder Quelle neu, wann immer eine von ihnen emittiert |
zip | Mehrere Flows kombinieren | Paart die n-te Emission jeder Quelle; wartet, bis jede Seite emittiert hat, bevor ein Paar erzeugt wird |
merge | Mehrere Flows kombinieren | Verschachtelt Emissionen mehrerer Quellen zu einer, in der Reihenfolge, in der sie eintreffen |
flatMapLatest | Zu einem neuen Flow wechseln | Bricht den vorherigen inneren Flow ab und wechselt zu einem neuen, jedes Mal wenn der äußere Flow emittiert |
flatMapConcat | Zu einem neuen Flow wechseln | Führt innere Flows einen nach dem anderen aus, in Reihenfolge, nie überlappend |
flatMapMerge | Zu einem neuen Flow wechseln | Führt innere Flows gleichzeitig aus und verschachtelt ihre Emissionen |
debounce | Rate Limiting | Verwirft Emissionen, bis eine ruhige Lücke verstreicht, dann emittiert nur die neueste |
distinctUntilChanged | Rate Limiting | Verwirft eine neue Emission, wenn sie gleich der letzten tatsächlich emittierten ist |
buffer | Backpressure | Lä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 |
conflate | Backpressure | Kurzform 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 |
catch | Fehlerbehandlung | Fä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.



