직관
코틀린 Flow는 에 대한
코틀린 식 접근이다: 가
값을 방출하고, 컨슈머가 그 값을 수집(collect)한다. flow { }는 이미 어딘가에서 돌아가고 있는
프로듀서에 대한 설명처럼 읽히고, collect { }는 컨슈머로서 거기에 탭(tap)을 거는 것처럼
보인다. 사람들이 List나 이벤트 버스에서 가져오는 그림이 바로 이거고, 특정한 방식으로 틀렸다.
- 의 빌더 블록이 바로 프로듀서이며, 그것은 실행 중인 프로세스가 아니라 레시피다. 컨슈머가 수집하기 전까지는 그 안의 아무것도 실행되지 않는다.
.collect()를 호출하면 그 레시피가 처음부터 실행되어, 오직 그 컨슈머 하나를 위한 값을 만들어낸다. 같은Flow에 두 번째로.collect()를 호출하면 프로듀서가 처음부터 다시, 독립적으로 실행된다.- 두 컨슈머가 하나의 값 스트림을 나눠 가지는 게 아니다. 각 컨슈머는 마치 그
Flow가 한 번도 수집된 적 없었던 것처럼, 처음부터 실행되는 자기만의 프로듀서를 갖는다.
그래서 flow { } 안의 네트워크 호출이나 로그 한 줄은 전체에서 한 번이 아니라 컬렉터당
한 번씩 실행되며, 이것이 Flow가 만들어내는 "잠깐, 이게 왜 두 번 실행됐지" 버그 리포트 중
가장 흔한 유형이다.
기본적으로 콜드하다: 빌더는 컬렉터마다 다시 실행된다
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"은 한 번이 아니라 두 번 출력된다. userRequests는 결과를
담고 있는 값이 아니라, 레시피를 담고 있는 Flow 객체다. .collect()를 호출할 때마다
그 레시피가 새로 실행되며, 각자 자신만의 api.fetchUser() 호출과 자신만의 방출을
가지고, 다른 컬렉터가 존재한다는 사실조차 전혀 모른다.
같은 버그, 좀 더 현실적인 형태
위의 토이 예제는 println이 단서를 줘서 분명히 잘못됐다는 게 보인다. Flow가 한두 계층
아래에 묻혀 있으면 같은 메커니즘이 실제 중복 네트워크 호출 버그를 일으킨다:
// ❌ 리포지토리가 콜드 Flow를 그대로 노출한다
class UserRepository {
fun observeUser(id: String): Flow<User> = flow {
emit(api.fetchUser(id)) // 컬렉터마다 다시 실행된다
}
}
// 두 컴포저블이 같은 호출 지점의 Flow를 각각 수집하고,
// 각자 독립적으로 자신만의 api.fetchUser(id) 호출을 트리거한다
@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)
// ...
}한눈에 봐서는 전혀 버그처럼 보이지 않는다. observeUser(id)는 "현재 사용자를
주세요"처럼, 게터와 같은 모양으로 읽힌다. 실제로는 "사용자를 가져오는 레시피를
주세요"이고, 호출하는 쪽이 둘이면 레시피도 둘, 네트워크 호출도 둘이 되는데, 겉보기엔
하나의 상태처럼 보인다.
근본 원리
이것이 콜드 스트림 대 핫 스트림 시맨틱이다. 콜드 스트림의 프로듀서는 컨슈머가 구독하기 전까지 아무 일도 하지 않으며, 구독할 때마다 처음부터 끝까지 독립적인 프로듀서를 새로 얻는다. 핫 스트림의 프로듀서는 특정 컨슈머와 무관하게 이미 실행 중이거나(또는 이미 현재 값을 가지고 있으며), 모든 컨슈머는 새로운 프로듀서를 시작하는 대신 그 동일한 진행 중인 프로듀서에 탭을 걸게 된다.
코틀린 Flow는 기본적으로 콜드하다. StateFlow와 SharedFlow가 아래에서 다룰, 의도된
핫 예외다.
다른 곳에서도: 같은 근본 원리, 다른 프레임워크
- RxJava/RxKotlin:
Observable.create { }도 같은 방식으로 콜드하며,subscribe()를 호출할 때마다 emitter 블록 전체가 다시 실행된다.PublishSubject와BehaviorSubject가 핫으로 가는 탈출구이며, 구독자가 다시 시작하는 게 아니라 이미 실행 중인 파이프에 탭을 거는 식이다. - Combine (Swift/SwiftUI): 평범한
Publisher는 콜드하며,.share()나.multicast()를 끼워 넣지 않으면 새 구독자마다 업스트림을 다시 실행한다.CurrentValueSubject와PassthroughSubject가 Combine의 핫 프리미티브이고,CurrentValueSubject는StateFlow에 거의 정확히 대응된다. 둘 다 항상 현재 값을 가지고 있고, 새 구독자에게 즉시 그 값을 건네준다. - JavaScript의 비동기 제너레이터 /
ReadableStream: 같은 규칙으로 콜드하며, 제너레이터 함수를 두 번째로 호출하거나(또는 스트림을 다시 파이프하면) 처음부터 다시 실행된다.EventTarget/EventEmitter는 핫하다. 아무도 듣고 있지 않아도 발생하며, 뒤늦게 등록한 리스너는 이미 일어난 일을 그냥 놓친다. - 안드로이드의 옛
LiveData: 구조적으로 핫하며, 콜드 빌더 블록에 대응하는 개념이 없다. 모든 옵저버가 이미 살아 있는 동일한 값 홀더에 붙는다. 이게 바로LiveData를 Flow로 마이그레이션할 때 사람들이 헷갈리는 이유 중 하나다.LiveData에 대해 만들어 둔 멘탈 모델은 평범한flow { }가 가지지 않는 핫 시맨틱을 가정하고 있기 때문이다.
핫 예외: StateFlow와 SharedFlow
StateFlow와 SharedFlow는 컬렉터마다 빌더를 다시 실행하지 않는데, 다시 실행할 빌더가
없기 때문이다. MutableStateFlow.value = x나 MutableSharedFlow.emit(x)를 어딘가
한 곳에서 정확히 한 번 호출하면, 모든 컬렉터가 그 동일한 하나의 업데이트 스트림을
관찰한다.
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() // 여기서 한 번만 실행된다
}
}
}uiState를 수집하는 모든 화면은 같은 값을, 같은 시점에 업데이트된 상태로 보게 된다.
프로듀서가 정확히 하나(위의 viewModelScope.launch)뿐이고, uiState는 그 현재
값을 들여다보는 창일 뿐이기 때문이다. 이것이 StateFlow의 핵심이다: 컨플레이트
(conflated)되어 있어서(새 컬렉터는 즉시 최신 값을 받지, 과거 모든 값의 리플레이를
받지 않는다) 스스로 완료되는 일이 없다.
SharedFlow는 더 일반화된 버전으로, StateFlow가 고정한 "항상 정확히 최신 값
하나"와 달리 replay 개수를 설정할 수 있고, 현재 값을 꼭 가지고 있어야 한다는
요구 사항도 없다. StateFlow는 replay = 1에 초기값이 있는 SharedFlow인
셈이다.
콜드 Flow를 의도적으로 핫하게 바꾸기: stateIn/shareIn
앞서 나온 리포지토리 버그에는 실제 해법이 있고, 그건 "Flow를 쓰지 말라"가 아니라
"콜드한 걸 공유하라"다:
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은 observeUser(id)의 콜드 레시피를 viewModelScope 안에서 정확히 한 번
실행하고, 그 결과를 모든 컬렉터가 공유하는 StateFlow로 노출한다. 앞의 예제에 나온
ProfileHeader와 ProfileDetails는 이제 같은 user를 수집하게 되고, 그 둘 뒤에는
정확히 하나의 api.fetchUser(id) 호출만 있게 된다.
SharingStarted.WhileSubscribed(5_000)는 실제로 공유 프로듀서가 언제 실행되는지를
결정하는 디테일이다: 첫 컬렉터가 나타나면 시작하고, 마지막 컬렉터가 떠난 뒤로도 5초간
살려 두고(그래서 빠른 화면 회전 같은 구성 변경으로 재시작되지 않는다), 아무도 더 듣고
있지 않으면 멈추고 해체한다. Eagerly는 즉시 시작해서 절대 멈추지 않고, Lazily는
첫 컬렉터가 나타나야 시작하지만 한 번 시작하면 멈추지 않는다. 어느 쪽이든 콜드에서
핫으로 바뀌는 건 똑같고, "공유 실행이 언제 시작되고 끝나는가"에 대한 답만 다를 뿐이다.
자주 쓰는 연산자 한눈에 보기
아래 연산자들 중 어느 것도 위에서 말한 "기본적으로 콜드하다"는 규칙을 바꾸지 않는다,
전부 더 복잡한 레시피일 뿐이다. 콜드 Flow를 combine이나 flatMapLatest로
감싸도 핫해지지 않는다. stateIn/shareIn으로 누군가가 공유하지 않는 한, 조합되거나
매핑된 Flow도 컬렉터마다 전체 체인을 다시 실행한다.
아래에서 다룰 는
정확히 그 질문이다: 프로듀서가 컨슈머보다 빠를 때 Flow가 무엇을 하는가, "영원히
기다린다"가 항상 맞는 답은 아니기 때문이다.
| 연산자 | 분류 | 하는 일 |
|---|---|---|
map / filter | 변환 | Sequence/List와 마찬가지로 방출을 하나씩 재구성하거나 걸러낸다 |
combine | 여러 Flow 조합 | 소스 중 어느 하나라도 방출할 때마다 각 소스의 최신 값으로부터 다시 계산한다 |
zip | 여러 Flow 조합 | 각 소스의 n번째 방출을 짝지으며, 쌍을 만들기 전에 양쪽이 모두 방출하기를 기다린다 |
merge | 여러 Flow 조합 | 여러 소스의 방출을 도착하는 순서대로 하나로 끼워 넣는다 |
flatMapLatest | 새 Flow로 전환 | 외부 Flow가 방출할 때마다 이전 내부 Flow를 취소하고 새것으로 전환한다 |
flatMapConcat | 새 Flow로 전환 | 내부 Flow들을 순서대로 하나씩 실행하며, 절대 겹치지 않는다 |
flatMapMerge | 새 Flow로 전환 | 내부 Flow들을 동시에 실행하며 그 방출들을 끼워 넣는다 |
debounce | 속도 제한 | 조용한 간격이 지나기 전까지 방출을 버리고, 지나면 최신 것만 방출한다 |
distinctUntilChanged | 속도 제한 | 새 방출이 실제로 방출된 마지막 값과 같으면 버린다 |
buffer | 백프레셔 | 느린 컬렉터보다 프로듀서를 앞서 달리게 해서 고정 크기 버퍼에 담아 두며, 즉시 서스펜드하지 않는다; 버퍼가 가득 찼을 때 어떻게 할지는 onBufferOverflow가 결정한다 |
conflate | 백프레셔 | buffer(capacity = 0, onBufferOverflow = BufferOverflow.DROP_OLDEST)의 줄임 표현: 실제 버퍼 없이, 항상 최신 값만 유지하고 컬렉터가 아직 처리하지 못한 값은 버린다 |
catch | 에러 처리 | 컬렉터를 취소하지 않고 업스트림 예외를 잡아낸다 |
buffer는 conflate가 그중 하나로 고정된 설정인 다이얼이다: buffer(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)는 대기 중인 값 하나를
보관하고 새 값이 도착하면 그 전 값을 버리는데, 이는 conflate()가 더 짧은
이름으로 하는 바로 그 일이다. 값 하나보다 더 큰 윈도우를 원하거나, 가장 오래된
값을 버리는 대신 BufferOverflow.DROP_LATEST/SUSPEND를 쓰고 싶다면 직접
buffer를 선택하라.
combine은 실무에서 콜드-재실행 버그를 가장 자주 숨기는 연산자다:
// ❌ combine이 두 콜드 Flow를 감싼다; 둘 다 여전히 각자의 레시피를
// 컬렉터마다 다시 실행하므로, 같은 두 리포지토리 Flow를 조합하는
// 화면이 둘이면 두 번이 아니라 네 번의 fetch가 발생한다
val summary = combine(repo.observeUser(id), repo.observeOrders(id)) { user, orders ->
Summary(user, orders)
}
// ✅ 조합된 결과를 한 번만 공유해서, 모든 컬렉터가 자기만의
// combine 실행을 시작하는 대신 같은 하나의 combine 실행에 탭을 건다
val summary = combine(repo.observeUser(id), repo.observeOrders(id)) { user, orders ->
Summary(user, orders)
}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)흔한 실수들
catch는 체인에서 자기보다 위에서 던져진 예외만 본다
flow {
emit(1)
throw RuntimeException("boom")
}
.catch { e -> emit(-1) } // ✅ catch가 그 아래 있으므로 위에서 던진 throw를 잡는다
.map { value ->
if (value == 1) throw RuntimeException("boom downstream")
value
}
.collect { println(it) }
// 그래도 크래시난다: 두 번째 throw는 체인에서 catch *뒤에* 일어나므로
// catch가 절대 보지 못한다. catch는 전체 수집을 감싸는 전역
// try/catch가 아니라, 그냥 레시피 안의 또 다른 콜드 링크일 뿐이다.사람들은 catch가 파이프라인 어디서든 무엇이든 잡아내는, 주변을 둘러싼
try/catch 블록처럼 동작하기를 기대하면서 가져다 쓴다. 그렇지 않다. catch는
map/filter와 같은 콜드 체인 안의 평범한 링크일 뿐이어서, 자기보다 업스트림
(즉 flow { } 빌더에 더 가까운 쪽)에서 던져진 예외만 잡고, 자기 뒤에 놓인
연산자가 던진 건 절대 잡지 못한다. 위에 있는 모든 걸 보고 싶다면 catch를
collect 바로 앞, 마지막 링크로 두어라.
잘못된 CoroutineContext에서 방출하면 "Flow invariant is violated"로 크래시난다
// ❌ 빌더 안의 withContext가 emit()이 실행되는 컨텍스트를 바꿔서,
// Flow의 컨텍스트 보존 보장을 깨뜨린다
flow {
withContext(Dispatchers.IO) {
emit(api.fetchUser()) // 런타임에서 IllegalStateException
}
}
// ✅ flowOn은 emit()이 flow { }가 만들어진 컨텍스트와 다른 곳에서
// 실행되는 일 없이, 업스트림 작업을 IO로 옮긴다
flow {
emit(api.fetchUser())
}.flowOn(Dispatchers.IO)flow { } 빌더는 emit()이 항상 컬렉터가 있는 것과 같은 CoroutineContext에서
실행된다는 것을 보장하므로, 컬렉터는 수집하는 그 무엇도 중간에 다른 디스패처로
몰래 옮겨가지 않는다고 믿을 수 있다. emit() 주위에 withContext를 호출하면
바로 그 보장을 깨뜨리고 예외가 던져진다. flowOn이 올바른 도구다: 그것은 자기보다
업스트림에 있는 모든 것을 주어진 디스패처로 옮기면서, 수집하는 쪽에 대해서는
emit()의 컨텍스트 보존 약속을 그대로 유지한다.
StateFlow는 현재 값과 구조적으로 같은 값을 재방출하지 않는다
data class UiState(val items: List<Item>)
val _state = MutableStateFlow(UiState(items = mutableListOf()))
// ❌ 같은 리스트를 제자리에서 변형한 뒤, 같은 참조를 다시 대입한다:
// 이전 값과 구조적으로 같으므로 아무것도 방출되지 않는다
_state.value.items as MutableList
(_state.value.items as MutableList).add(newItem)
_state.value = _state.value // 아무 효과 없음, 컬렉터는 newItem을 절대 보지 못한다
// ✅ 진짜로 새로운 값이므로 equals()가 차이를 보고 방출한다
_state.value = _state.value.copy(items = _state.value.items + newItem)StateFlow는 컨플레이트되어 있다: .value에 대입해도, 새 값이 현재 값과
equals()가 아닐 때만 컬렉터에게 방출된다. 들고 있는 컬렉션을 제자리에서
변형하고 같은 참조를 다시 대입하는 건 업데이트처럼 보이지만, 참조 자체는
실제로 아무것도 바뀌지 않았으므로 StateFlow 입장에서는 업데이트가 아니다.
이게 바로 불변 데이터 클래스와 copy()가 StateFlow 주변의 관례가 된 이유이고,
단순한 스타일 선호가 아니다.
awaitClose를 빠뜨리면 callbackFlow가 즉시 크래시난다
는
emit()을 직접 호출하게 해주지 않고 콜백/리스너를 통해 값을 건네주는 API, 예를
들면 위치 제공자나 View의 클릭 리스너 같은, 평범한 flow { }로는 표현할 수 없는
API를 위해 존재한다. 그래도 내부적으로는 여전히 콜드 Flow이고, 같은 flow { }
형태로 만들어지며, 그냥 방출을 대신하는 콜백이 등록돼 있을 뿐이다.
// ❌ 블록이 콜백을 등록한 직후 바로 반환되며, 서스펜션 포인트가
// 없다: callbackFlow는 이를 버그로 간주하고 예외를 던진다
fun locationUpdates(client: LocationClient): Flow<Location> = callbackFlow {
val callback = object : LocationCallback() {
override fun onLocationResult(result: LocationResult) {
trySend(result.lastLocation)
}
}
client.requestLocationUpdates(callback)
// IllegalStateException: callbackFlow 블록이 종료됐지만
// 채널이 닫히지 않아서, 위의 콜백을 해제할 결정적인
// 시점이 남아있지 않다
}
// ✅ awaitClose는 컬렉터가 취소될 때까지(또는 채널이 다른 방식으로
// 닫힐 때까지) 서스펜드하며, 위의 콜백 등록을 해제할 수 있는
// 유일하게 안전한 지점이다
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) }
}callbackFlow의 계약 전체는 등록한 콜백을 정리할 수 있는 결정적인 순간을 하나
갖는다는 것을 중심으로 만들어져 있다. 블록이 스스로 반환될 수 있다면 그런 순간이
없고, 콜백은 그냥 누구도 해제할 수 없는 채로 영원히 등록된 상태로 새게 된다.
그래서 callbackFlow는 런타임에 그 계약을 강제한다: 블록은 거의 항상
awaitClose { }인 서스펜션 포인트로 끝나야 하며, 그렇지 않으면 조용히 새는 대신
예외를 던진다.
callbackFlow도 콜드다, 즉 콜백이 컬렉터마다 다시 등록된다
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) }
}콜백을 callbackFlow로 감싼다고 해서 기본적으로 콜드하다는 성질에서 빠지는 게
아니다, 여전히 같은 flow { } 형태의 레시피로 만들어져 있다. 두 컬렉터는 OS에
두 개의 별도 위치 리스너를 등록하고, 각각 자신의 컬렉터 취소에 따라 독립적으로
해체된다. 해법은 위와 같다: 위치 데이터를 원하는 모든 화면이 직접
locationUpdates()를 호출하게 하는 대신, 단일 컬렉터보다 오래 사는 스코프에서
한 번 shareIn하라.
Flow에는 .value가 없고 StateFlow에는 있다, 둘 중 하나를 의도했는데 다른 쪽을 가져다 쓰는 건 언제든 터질 타입 에러다
평범한 Flow<T>는 동기적으로 읽을 수 없다, 수집하기 전까지는 아무것도 실행되지
않으니 읽을 현재 값이 없기 때문이다. StateFlow<T>는 항상 하나를 갖고 있다.
Flow<T> 매개변수를 범용적으로 받으면서 실제로는 .value가 필요한 코드는,
그 함수가 결코 보장된 적 없는 핫 시맨틱을 조용히 가정했다는 신호다.
Flow는 이미 값을 흘려보내고 있는 파이프가 아니라 레시피다: 기본적으로
콜드하며, collect()를 호출할 때마다 자기만의 독립적인 복사본을 다시 실행한다.
그리고 StateFlow/SharedFlow(또는 콜드 Flow 위에 올린 stateIn/shareIn)는
그것을 한 번만 실행하고 모두가 결과를 공유하도록 하는, 의도된 선택적 전환이다.



