KWAS Academy
Learn. Build. Master.
QUICK START:HTMLCSSJavaScriptTypeScriptPythonSQLReactNext.jsNode.jsLinux & UbuntuKotlinSwiftC# / .NETJavaGoRustC++DSASystem DesignDevOpsCybersecurityAI / ML
Advanced 24 min readModule: Module 8: Asynchronous Reactive Streams with Kotlin Flow & StateFlow

Reactive Streams with Kotlin Flow & StateFlow

Build reactive asynchronous pipelines using Kotlin Flow (cold streams), StateFlow (observable state holders), and SharedFlow (event broadcasting).

What You Will Learn in This Lesson

  • The difference between Cold Streams (Flow) and Hot Streams (StateFlow/SharedFlow)
  • Flow builder functions: `flow { emit(...) }`, `flowOf()`, and `.asFlow()`
  • Intermediate flow operators: `filter`, `map`, `debounce`, `distinctUntilChanged`, `combine`
  • StateFlow for modern MVI/MVVM reactive UI state management

Introduction & Core Concept

Kotlin Flow is a reactive stream library built natively on top of Coroutines. While a suspend function asynchronously returns a single value, a Flow asynchronously emits multiple sequentially calculated values over time. Flow adheres to the Reactive Streams specification with built-in backpressure and zero thread-blocking.
WHY DOES THIS MATTER IN THE REAL WORLD?

Modern applications require real-time streaming updates: stock market tickers, chat messages, live geolocation tracking, and UI search bar autocomplete. Flow provides a clean, coroutine-native alternative to RxJava without complex reactive operators.

Syntax & Structure

kotlin
fun getNumbers(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

Streaming Stock Price Ticker with Flow and Transformations

kotlin
kotlin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Reactive Stream Pipeline with Kotlin Flow
package com.kwasacademy.flow
 
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
data class StockTick(val symbol: String, val price: Double)
 
// Cold Flow: Begins executing ONLY when a terminal operator (collect) is invoked
fun streamStockPrices(): Flow<StockTick> = flow {
    val prices = listOf(150.25, 151.80, 149.90, 153.40, 155.10)
    for (p in prices) {
        delay(50) // Simulates streaming interval
        emit(StockTick("KWAS", p))
    }
}
 
fun main() = runBlocking {
    println("Subscribing to real-time stock stream...")
 
    streamStockPrices()
        .filter { it.price > 150.0 }
        .map { "Ticker Update: ${it.symbol} -> $${it.price}" }
        .collect { message ->
            println("  [Stream Event] $message")
        }
 
    println("Stream completed cleanly.")
}

Line-by-Line Technical Breakdown

1StateFlow vs SharedFlow: `StateFlow` is a hot observable state holder that always maintains and replays its current value (perfect for UI state). `SharedFlow` broadcasts events to multiple subscribers without storing state (perfect for one-off notifications or navigation events).

Try It Yourself (Interactive Editor)

Modify the code in real-time and click Run to test live browser output and console logs.

Intelligent Code Runner & Live Sandbox[KOTLIN]
KOTLIN SOURCE EDITOR
Interactive Live Code

Common Mistakes & How to Avoid Them

#1: Performing heavy blocking operations directly inside flow operators without flowOn(Dispatchers.IO).

flowOn shifts the execution context of upstream operators to the specified Dispatcher, keeping the collector thread responsive.

Incorrect / Antipattern
flow.map { heavyDatabaseCall() }
Correct / Professional Solution
flow.map { heavyDatabaseCall() }.flowOn(Dispatchers.IO)

Industry Best Practices & Professional Standards

  • Use `StateFlow` in ViewModels and backend state managers to expose observable immutable state.
  • Use `flowOn(Dispatchers.IO)` to designate where upstream stream processing takes place.
  • Use `.debounce(300)` for search input text streams to eliminate redundant network calls.

Lesson Summary & Core Takeaways

  • Flow emits multiple asynchronous values over time with built-in backpressure.
  • Cold Flows execute only when `.collect()` is invoked.
  • `StateFlow` acts as an observable state container for reactive UI and backend systems.