04.8.2.2 Flow、Channel 与背压
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.2 协程与并发
本节要解决的问题
本节覆盖 Kotlin Flow 的冷流本质与构建器、常用变换与组合操作符、flowOn 上下文规则、缓冲与背压处理,Channel 容量与溢出策略,produce/actor 与消费 API 的废弃演进,SharedFlow/StateFlow 热流模型,callbackFlow/channelFlow 桥接,以及异常重试、冷热流生命周期与 UI 背压。版本基线为 kotlinx.coroutines 1.8+/1.9、Kotlin 2.x。
04.8.2.2-001 Flow 是什么,为什么说它是冷流?
一句话结论
Flow 是按协程实现的冷异步数据流:每次 collect 订阅时才执行上游收集器代码,把值逐个向下游发送;没有订阅者时上游不产生数据,多个订阅各自独立触发一次上游流程。
概念解释
- 冷流:订阅才激活,类似挂起函数的多次调用。
- 热流:数据源独立于订阅者存活(SharedFlow/StateFlow)。
- Flow 类型只描述数据流,不含运行中的生产者。
原理流程
- 构造 Flow 时只保存收集器 lambda,不执行。
- 调用 collect 时启动协程运行上游。
- 上游
emit把值交给下游处理。 - 再次 collect 重新执行一遍上游。
代码或图示
val flow = flow {
println("start") // 每次 collect 才打印
emit(1)
emit(2)
}
flow.collect { println(it) }
flow.collect { println(it) } // 上游再跑一遍
常见误区
- 以为 Flow 创建时就开始发数据:冷流订阅才激活。
- 以为两次 collect 共享同一上游状态:各自独立执行。
追问
- 冷流与挂起函数的共性?答:都是调用时才执行,结果按需产出。
- 想让上游共享给多个订阅者用什么?答:SharedFlow/shareIn,把冷流转为热流。
04.8.2.2-002 Flow 的 emit 与 collect 之间是怎样的调用关系?
一句话结论
emit 是挂起函数,把当前值交给下游收集器处理;默认上下游在同一条协程链路里顺序执行,下游处理完一个值,上游才能 emit 下一个,这就是默认无缓冲的背压语义。
概念解释
- emit 等待下游当前元素处理完成才返回。
- 收集器是上游收集器 lambda 逐级包装后的调用链。
- 插入缓冲操作符后上下游才解耦为独立协程。
原理流程
- collect 启动收集协程,沿操作符链向下调用。
- 上游 emit(x) 调下游处理函数。
- 下游处理完返回,emit 才继续下一个值。
- 下游慢时上游被挂起在 emit 点。
代码或图示
flow {
emit(1) // 等 collect 处理完 1 才 emit 2
emit(2)
}.collect { value ->
println(value)
}
常见误区
- 以为 emit 把值丢进队列立即返回:默认顺序调用,不排队。
- 以为上游和下游天然并行:默认同一协程顺序执行。
追问
- 如何让上下游解耦并行?答:
buffer()插入通道缓冲,或用 conflate/合并操作符。 - emit 能在并发协程里多次调用吗?答:flow 收集器要求串行 emit,并发发射需 channelFlow 等带通道的构建器。
04.8.2.2-003 flow {} 构建器与 flowOf、asFlow 各用于什么场景?
一句话结论
flow {} 用挂起收集器自由 emit 动态/异步值;flowOf(a,b,c) 包装固定可变参数常量;asFlow() 把集合、序列或挂起函数适配为 Flow;按数据来源形态选择构建器。
概念解释
- flow{}:可调用其他 suspend 源、循环生成值。
- flowOf:一次性常量序列,无异步逻辑。
- asFlow:既有 Iterable/Sequence/Function 转 Flow 进入数据流管道。
原理流程
- 判定数据来源:动态异步用 flow{}。
- 常量列表用 flowOf。
- 已有集合/序列用 asFlow 适配。
- 三者产出的都是冷 Flow,订阅时执行。
代码或图示
val dynamic = flow {
repeat(3) { emit(readFromApi()) }
}
val constants = flowOf(1, 2, 3)
val fromList = listOf("a", "b").asFlow()
常见误区
- 在 flow{} 里直接启动独立线程发数据:收集器应保持顺序,异步并发发射用 channelFlow。
- 用 flowOf 包装每次订阅都要重算的值:应放 flow{} 内调用。
追问
- 挂起函数返回单值怎么转 Flow?答:
::suspendFunction.asFlow()或 flow{ emit(suspendFunction()) }。 - flow{} 内能 launch 子协程吗?答:默认不建议;需要并发多源合并用 channelFlow/多 Flow 组合。
04.8.2.2-004 Flow 的生命周期从哪里开始、到哪里结束?
一句话结论
Flow 生命周期从 collect 协程启动开始,到上游正常完成、下游取消或发生异常结束;冷流每次订阅独立开始与结束,取消 collect 协程会沿链向上游传播取消。
概念解释
- 生命周期绑定收集协程的 Job。
- 上游在收集协程内运行,取消沿链传播。
- 完成事件经 onCompletion/catch 感知。
原理流程
- collect 启动协程,上游收集器开始执行。
- 值逐个向下游流动。
- 上游 emit 完毕,Flow 正常结束。
- 收集协程取消 → 取消信号沿操作符链到达上游挂起点。
代码或图示
val job = scope.launch {
sourceFlow.onCompletion { cause -> println("done $cause") }.collect { }
}
job.cancel() // 取消沿链传向上游
常见误区
- 以为 Flow 有独立后台生命周期:冷流依附收集协程。
- 以为取消下游不影响上游:取消会反向传播到上游。
追问
- 如何感知正常结束与异常结束?答:onCompletion 的 cause 为 null 是正常结束,否则是异常/取消原因。
- 热流生命周期由谁管理?答:由上游共享作用域(shareIn/StateFlow 持有者)管理。
04.8.2.2-005 map、filter、transform 在 Flow 上的行为有何区别?
一句话结论
map 一对一变换当前值;filter 谓词保留满足条件的值;transform 是通用变换,可对每个值 emit 任意数量(零个、一个或多个)派生值,三者都是冷操作符,订阅时才逐级执行。
概念解释
- map:输入一个值,输出一个值。
- filter:不改变值,决定是否放行。
- transform:自由调用 emit,结构最灵活。
原理流程
- 上游值进入操作符链。
- map 变换后向下游 emit 一个结果。
- filter 谓词不通过则不向下游发送。
- transform 可在处理中 emit 多条派生值。
代码或图示
source
.filter { it > 0 }
.map { it * 2 }
.transform { value ->
emit("raw:$value")
emit("double:${value * 2}")
}
常见误区
- 用 transform 只做一对一变换却写得很绕:简单场景优先 map/filter,可读性更好。
- 在 map/filter 里做长阻塞:挂起操作符内阻塞会卡住整条链。
追问
- transform 能发射上游没有的补充值吗?答:能,但值来自当前元素上下文,额外独立源应组合其他 Flow。
- 操作符内异常如何传播?答:沿链抛给 collect 协程,可被 catch 操作符捕获。
04.8.2.2-006 onEach 与 map 有什么不同?
一句话结论
onEach 对每个值执行副作用但保持原值向下游传递;map 改变值并把变换结果发出;onEach 常用于日志、埋点、进度观察,不承担数据变换职责。
概念解释
- onEach 返回与上游相同的类型。
- map 返回变换后的新类型。
- 两者都是顺序处理元素的中间操作符。
原理流程
- 元素到达 onEach,执行副作用 lambda。
- 原值继续向下游。
- map 把 lambda 返回值作为新元素发出。
- 副作用失败同样中断流并传播异常。
代码或图示
source
.onEach { log("emit $it") }
.map { it.toString() }
.collect { }
常见误区
- 在 onEach 里改外部可变状态并依赖下游读到:副作用应尽量集中到 collect。
- 用 onEach 做类型转换:应使用 map。
追问
- onEach 能抛出异常中断流吗?答:能,lambda 异常沿链传播。
- onEach 与 collect 的副作用位置差别?答:onEach 在中间链,仍可被上游重试/缓冲影响;collect 是最终落点。
04.8.2.2-007 flatMapConcat、flatMapMerge、flatMapLatest 如何选择?
一句话结论
flatMapConcat 顺序合并每个上游元素派生的 Flow,前一个子流完成才处理下一个;flatMapMerge 并发收集多个子流并合并结果;flatMapLatest 新元素到来时取消上一个子流,只保留最新派生结果。
概念解释
- concat:保序、低并发。
- merge:高并发、结果按到达顺序混合。
- latest:响应最新值,丢弃旧任务结果。
原理流程
- 上游每个元素映射为一个子 Flow。
- Concat 串行收集子流,合并发射。
- Merge 并发启动多个子流,结果到达即发射。
- Latest 新元素到达取消旧子流,切换到新子流。
代码或图示
query.flatMapLatest { q -> searchApi(q) }.collect { }
ids.flatMapMerge { id -> userApi.get(id) }.collect { }
常见误区
- 对搜索联想框用 concat:输入连续变化时旧结果排队,体验滞后。
- 对强依赖顺序的任务用 merge:结果交错可能乱序。
追问
- merge 的并发度可配吗?答:有 concurrency 参数限制并发子流数量(参数名与默认值以版本文档为准,待确认)。
- latest 取消旧子流时资源如何释放?答:子流需响应取消,finally 释放订阅与连接。
04.8.2.2-008 zip 与 combine 在多流组合上有何差别?
一句话结论
zip 按位置配对:两个流各取一个值组成一对,某个流缺值时等待,严格一一对应;combine 任一流有新值就用各流最新值组合,数据流进度不同步时基于最新快照派生结果。
概念解释
- zip:类似拉链,保位置,适合配对事件。
- combine:基于最新值,适合状态聚合。
- 两者都把多个 Flow 合成一个新 Flow。
原理流程
- zip 维护各流队列,成对取出组合。
- 一流速另一流慢时快者排队等待。
- combine 订阅所有源,任一更新触发组合 lambda。
- 组合输出基于当前各源最新值。
代码或图示
val paired = names.zip(ages) { name, age -> Person(name, age) }
val state = combine(userFlow, orderFlow) { u, o -> Profile(u, o) }
常见误区
- 用 zip 聚合两个状态流:状态更新频率不同会互相等待,应用 combine。
- 以为 combine 保留历史配对:它只保留各源最新值。
追问
- 三个以上流怎么 combine?答:combine 有多个 Flow 重载,参数对应各流最新值。
- zip 一个流完成后另一个还在发怎么办?答:流随已完成源结束,剩余值不再配对。
04.8.2.2-009 Flow 的 catch 操作符捕获哪一层的异常?
一句话结论
catch 捕获其上游操作符与上游 Flow 抛出的异常,并可决定发射兜底值或继续传播;catch 下游(之后的操作符与 collect)抛出的异常不会被该 catch 捕获,需要再包一层。
概念解释
- catch 是上游异常兜底,类似 try/catch 包住上游链。
- 捕获后可 emit 兜底值,或重新抛异常。
- 下游异常属于 catch 之后的链路。
原理流程
- 收集协程沿链向下执行。
- 上游某节点抛异常,向上回溯经过 catch。
- catch lambda 处理异常,可 emit 兜底值。
- 异常若在 catch 之后抛出,直接到 collect 协程。
代码或图示
source
.catch { emit(fallback()) }
.map { it.toString() } // 这里抛出的异常不被上面 catch 捕获
.collect { }
常见误区
- 把 catch 放在链尾以为能捕获所有异常:下游异常在 catch 之外。
- catch 吞掉取消异常:应放行 CancellationException,不要当普通业务错误处理。
追问
- catch 里能观察异常原因吗?答:lambda 参数为 Throwable,可判断类型与是否取消。
- 想统一兜底所有链路怎么做?答:必要时在 collect 协程内 try/catch,或分层放置 catch。
04.8.2.2-010 retry 操作符如何工作,哪些异常不该重试?
一句话结论
retry 在上游失败时按条件重新订阅上游,达到次数或条件不满足则把异常向下游传播;取消异常(CancellationException)不应重试,不可预期的编程错误与永久性业务失败也应避免盲目重试。
概念解释
- retry 是冷操作符:重试 = 重新跑一遍上游收集器。
- 可配次数、谓词与超时退避。
- 重试会重复上游副作用,需保证幂等。
原理流程
- 上游发射中抛异常,回溯到 retry。
- 谓词判断是否可重试,次数未用尽则重新订阅上游。
- 重试成功继续发射;用尽后异常向下游传播。
- 取消异常直接放行,不进入重试。
代码或图示
source.retry(3) { e -> e is IOException && e !is CancellationException }
.collect { }
常见误区
- 对非幂等写操作重试:可能重复下单/扣款。
- 不区分异常类型盲目重试 5 次:放大故障与下游压力。
追问
- 重试间隔怎么加?答:retryWhen 内按异常与次数 delay 退避,注意放行取消异常。
- 重试会重新执行 onEach 副作用吗?答:会,上游重新订阅,链上前置副作用重跑。
04.8.2.2-011 onCompletion 能拿到哪些结束原因?
一句话结论
onCompletion 在 Flow 结束时回调,参数 Throwable?:null 表示正常完成,非 null 是异常或取消原因;它既能观察正常结束,也能观察异常终止,但不能像 catch 那样恢复发射兜底值。
概念解释
- 位置在上游结束时触发,含异常路径。
- 与 finally 语义对应,适合清理资源。
- 区别 catch:catch 可兜底发射,onCompletion 只观察。
原理流程
- 上游正常发完,cause 为 null 触发回调。
- 上游异常终止,cause 携带异常。
- 收集协程取消,cause 携带取消异常。
- 回调内可清理订阅、记录结束日志。
代码或图示
source.onCompletion { cause ->
if (cause == null) log("completed") else log("failed: $cause")
}.collect { }
常见误区
- 在 onCompletion 里 emit 新值恢复流:它不提供发射通道,兜底应放 catch。
- 以为只有异常结束才回调:正常结束同样触发。
追问
- onCompletion 与 catch 配合顺序?答:catch 处理上游异常并可兜底;onCompletion 在结束(含兜底后正常结束)时观察原因。
- 取消原因如何区分?答:cause 为 CancellationException 即取消路径。
04.8.2.2-012 Flow 能否从多个并发源合并发射?
一句话结论
能:channelFlow 可在收集器内 launch 多个并发子协程并发 send;多个现成 Flow 用 merge/combine 等组合;普通 flow {} 收集器要求串行 emit,不能并发从多个协程发射。
概念解释
- flow{}:单收集器顺序发射。
- channelFlow:内部带通道,支持并发 send。
- merge:把多个 Flow 合并为一个流。
原理流程
- channelFlow 建立通道与收集协程。
- 内部 launch 多个生产者协程向通道 send。
- 通道把值串行交给下游。
- 流取消时子生产者随作用域取消。
代码或图示
channelFlow {
launch { send(a()) }
launch { send(b()) }
awaitClose { /* 清理 */ }
}
常见误区
- 在 flow{} 里并发 emit:违反串行约束,行为不可靠。
- 多源合并忘记取消子协程:流结束后子生产者可能悬空。
追问
- channelFlow 与 callbackFlow 关系?答:callbackFlow 是 channelFlow 的回调专用特化,awaitClose 反注册。
- merge 多个 Flow 的并发归属?答:各源在各自调度/作用域运行,结果汇入下游。
04.8.2.2-013 filterNotNull、distinctUntilChanged 解决什么数据清洗问题?
一句话结论
filterNotNull 剔除 null 值并把类型收窄为非空;distinctUntilChanged 只在相邻元素与上一个不同时放行,抑制重复连续值,适合状态流去抖与重复渲染。
概念解释
- 类型收窄:filterNotNull 后 Flow 元素类型去掉可空。
- 相邻去重:只比较当前与上一个,不是全局去重。
- 两者都是中间冷操作符。
原理流程
- filterNotNull 判断非空才向下游发送。
- distinctUntilChanged 记录上一个发射值。
- 当前值等于上一个则忽略,不等则放行并更新记录。
- 自定义相等可用谓词或键选择器。
代码或图示
source.filterNotNull().distinctUntilChanged { old, new -> old.id == new.id }
常见误区
- 以为 distinctUntilChanged 全局去重:重复值隔若干其他值后仍会再次发射。
- 用对象引用比较数据相等:复杂对象应选关键字段比较。
追问
- 状态流连续重复对象为什么要去重?答:避免下游无意义更新与重复渲染。
- 全局历史去重用什么?答:结合集合/状态判断,不属于该操作符职责。
04.8.2.2-014 drop、take、first、single 等末端/限长操作符行为如何?
一句话结论
drop(n) 跳过前 n 个值;take(n) 只取前 n 个后结束流;first 取第一个值并取消上游;single 要求流恰好一个值,多于或少于一个都抛异常。
概念解释
- 限长操作符在条件满足后取消上游收集。
- first 是末端挂起取数,不返回 Flow。
- single 用于确定唯一结果的校验场景。
原理流程
- 元素流过限长操作符计数。
- take/drop 达到条件后放行或结束。
- first 取到值后取消收集协程。
- single 收集过程中计数,终态校验数量。
代码或图示
val first = source.first()
val limited = source.take(5)
常见误区
- 对可能空的流用 single:无元素直接抛异常,应 firstOrNull。
- 以为 take 后上游仍继续跑:条件满足即取消上游。
追问
- 取第一个匹配值用什么?答:
first { predicate },找到即取消上游。 - 末端收集与中间操作符如何区分?答:返回 Flow 是中间;返回挂起结果/Unit 是末端。
04.8.2.2-015 Flow 如何转换成集合或挂起取单值?
一句话结论
末端挂起操作符把流汇聚为集合或单值:toList()、first()/firstOrNull()、single()、last()、reduce/fold;这些操作符启动收集并等待流结束,返回同步结果给挂起调用点。
概念解释
- 汇聚操作符终结 Flow 管道。
- toList 保留全部元素。
- fold 带初始值累计,reduce 用首元素作初值。
原理流程
- 调用末端操作符启动收集。
- 元素逐个累加/收集到目标结构。
- 流结束返回结果。
- 中途异常沿收集协程传播。
代码或图示
val list = source.toList()
val sum = source.reduce { acc, v -> acc + v }
常见误区
- 对无限流调用 toList:流不结束则永不返回,无限流应用 take 限长。
- 在 collect 之外又调末端操作符:两次订阅,冷流上游跑两遍。
追问
- 末端操作符在哪个调度器运行?答:继承收集协程上下文,上游调度受 flowOn 规则约束。
- 转换为 StateFlow/SharedFlow 用什么?答:stateIn/shareIn,属于热流转换。
04.8.2.2-016 flowOn 的作用边界是什么?
一句话结论
flowOn 只改变其上游操作符运行的调度器,不影响下游;下游仍在收集协程自身上下文上运行;flowOn 通过插入缓冲通道把上游与下游放到不同调度器,不能用它切换整条链的全局上下文。
概念解释
- 调度边界:flowOn 之上走指定 Dispatcher,之下走收集上下文。
- 与 withContext 的区别:withContext 切换当前协程整段;flowOn 只隔上游。
- 一个链可多次 flowOn 形成多段调度边界。
原理流程
- flowOn(dispatcher) 在上游与下游间插入通道。
- 上游操作符在指定 Dispatcher 运行并发 send 到通道。
- 下游从通道取值,运行在收集协程上下文。
- 多次 flowOn 按就近边界决定每段调度。
代码或图示
source
.map { cpuWork(it) } // 此段在 Default
.flowOn(Dispatchers.Default)
.collect { render(it) } // 下游在收集上下文(如 Main)
常见误区
- 以为 flowOn(Dispatchers.Main) 让下游回主线程:只影响它上面的上游。
- 在 flowOn 块内假设下游线程与上游一致:两者可能不同线程。
追问
- 为什么 flowOn 需要缓冲通道?答:跨调度器上下游解耦,值经通道传递。
- 多次 flowOn 顺序如何影响调度?答:每段以距离最近的上游 flowOn 为准,下游跟随收集上下文。
04.8.2.2-017 Flow 上下文规则:为什么不能随便在收集器里改调度器?
一句话结论
Flow 规定上游收集器应保持收集协程的上下文,不能在 flow {} 内擅自切换到其他线程池;需要隔离阻塞任务时用 flowOn 在上游边界指定调度器,这一约束保证上下文可预测、取消传播一致。
概念解释
- 收集器内直接 launch/切线程会绕过上下文规则。
- 阻塞式旧库调用应被 flowOn(IO) 边界包裹。
- 违反上下文约束可能导致取消与异常不可控。
原理流程
- 收集协程上下文沿链传递。
- flowOn 合法地在上游段替换 Interceptor。
- 收集器内手动开线程脱离 Job 父子链。
- 取消无法到达手动线程,资源泄漏风险。
代码或图示
flow {
// 不在这里自行切换线程;用 flowOn(IO) 包这段
emit(blockingRead())
}.flowOn(Dispatchers.IO)
常见误区
- 在 flow{} 里
withContext(IO)包裹整段:应优先 flowOn 表达上游调度边界。 - 以为上下文规则只是建议:违反会破坏结构化并发与取消传播。
追问
- channelFlow 内部 launch 的子协程归属?答:归 channelFlow 收集作用域,随流取消。
- 如何验证上游跑在哪个调度器?答:在操作符内读取线程名/上下文 Interceptor 日志。
04.8.2.2-018 缓冲 buffer() 在 Flow 里解决什么问题?
一句话结论
buffer() 在上下游之间插入缓冲通道,让上游不必等下游处理完当前值即可继续发射,缓解下游慢导致的上游挂起;无 buffer 时默认是 rendezvous(零缓冲)顺序调用。
概念解释
- 缓冲解耦上下游执行节奏。
- 通道容量可配,满了按策略处理。
- 适合生产快、消费慢且允许排队的场景。
原理流程
- buffer 建立通道,上游 send 到通道。
- 下游从通道取数处理。
- 通道未满上游可继续,满则挂起或按溢出策略处理。
- 流取消时通道与上下游一起终止。
代码或图示
source.buffer(Channel.BUFFERED).collect { slowProcess(it) }
常见误区
- 对要求实时最新值的流盲目 buffer:旧值积压延迟刷新。
- 缓冲无上限导致内存增长:需评估容量与溢出策略。
追问
- buffer 与 flowOn 的关系?答:flowOn 内部已带缓冲通道;显式 buffer 可再调整容量。
- 缓冲大小如何选?答:按生产消费速率差、内存预算与时效性确定。
04.8.2.2-019 conflate 与 collectLatest 都丢弃中间值,差别是什么?
一句话结论
conflate 保留通道最新值:下游慢时上游持续发,下游只拿得到最新快照,不取消正在执行的下游处理;collectLatest 新值到达时取消上一个仍在执行的下游处理块,重新对新值执行,适合「只关心最新结果」的处理。
概念解释
- conflate:上游不中断,合并最新值,下游串行处理最新项。
- collectLatest:下游处理器可被新值取消重启。
- 两者都降低积压,但取消语义不同。
原理流程
- conflate 通道策略为保留最新,旧值被覆盖。
- 下游取最新值处理,处理期间新值继续覆盖。
- collectLatest 每个值启动新处理协程。
- 新值到达取消上一个处理协程,finally 清理旧任务。
代码或图示
source.conflate().collect { render(it) }
source.collectLatest { value -> fetchAndShow(value) }
常见误区
- 在 collectLatest 块内做不可中断的长事务:取消会打断中间状态,需可恢复设计。
- 用 conflate 替代并发合并:conflate 只保最新,不并行处理。
追问
- collectLatest 取消旧块时资源怎么释放?答:块内 try/finally 或 NonCancellable 清理订阅。
- 实时位置/搜索结果选哪个?答:倾向 collectLatest 取消旧请求;状态快照刷新可用 conflate。
04.8.2.2-020 Flow 默认背压策略是什么?
一句话结论
默认无额外缓冲(rendezvous 语义):上游 emit 挂起直到下游处理完当前元素,下游慢直接反压到上游;没有自动丢值或无限排队,需要缓冲、合并或最新值策略时显式使用对应操作符。
概念解释
- 背压:上游速度受下游处理能力约束。
- 默认策略是顺序等待,不丢弃。
- 缓冲/合并/最新值是可选的背压调整。
原理流程
- 上游 emit(x) 调下游处理。
- 下游未返回前上游挂起。
- 下游完成,上游继续下一值。
- 插入 buffer/conflate 后才改变排队或丢值行为。
代码或图示
// 默认:下游慢则上游在 emit 点挂起
source.collect { process(it) }
常见误区
- 以为 Flow 自带无限队列:默认零缓冲,不会积压无限多元素。
- 以为下游慢会自动丢值:默认保留顺序不丢。
追问
- 阻塞下游会卡住上游吗?答:会,同链顺序执行;应把阻塞任务移到独立调度边界。
- 背压策略在 Channel 上如何表达?答:容量与溢出策略组合,见 Channel 章节。
04.8.2.2-021 Channel 在协程间传递数据时扮演什么角色?
一句话结论
Channel 是协程间通信的队列:生产者 send 元素,消费者 receive/迭代接收;它解耦发送与接收节奏,自带容量、挂起等待与取消传播,是 Flow 与 produce/actor 的底层通道原语。
概念解释
- 协程间通过通道传值,不直接共享可变状态。
- 通道关闭表示不再有元素。
- 通道挂起在满/空时等待,不占自旋线程。
原理流程
- 创建指定容量与策略的 Channel。
- 生产者 send:未满入队,满则挂起或按策略处理。
- 消费者 receive:有值取走,空则挂起等待。
- 关闭后消费者收到结束信号;取消时通道随作用域终止。
代码或图示
val channel = Channel<Int>()
scope.launch { channel.send(1) }
scope.launch { println(channel.receive()) }
常见误区
- 把 Channel 当普通线程安全队列:它是挂起式通信原语,绑定协程取消模型。
- 忘记关闭通道:消费者可能一直挂起等待结束信号。
追问
- Channel 与 Flow 的关系?答:Flow 建立在通道/收集器抽象之上,冷流管道可经 channelFlow 接通道。
- 多个生产者/消费者能共用一个通道吗?答:能,通道在协程间共享收发。
04.8.2.2-022 Channel 容量类型有哪些?
一句话结论
容量策略包括 RENDEZVOUS(零缓冲,发送接收配对才通过)、BUFFERED(默认缓冲容量)、CONFLATED(只保留最新一个)、UNLIMITED(无上限缓冲);容量与溢出策略共同决定满时行为。
概念解释
- RENDEZVOUS:零容量,send 挂起直到 receive 到达。
- BUFFERED:使用默认缓冲大小。
- CONFLATED:新值覆盖旧值,只留最新。
- UNLIMITED:无限排队,受内存约束。
原理流程
- 创建通道时选容量类型。
- 生产者 send 按容量入队或挂起/覆盖。
- 消费者按容量语义取数。
- CONFLATED 只投递最新,UNLIMITED 不拒绝入队。
代码或图示
val rendezvous = Channel<Int>(Channel.RENDEZVOUS)
val conflated = Channel<Int>(Channel.CONFLATED)
val unlimited = Channel<Int>(Channel.UNLIMITED)
常见误区
- UNLIMITED 在高频源上不设监控:内存可能无限增长。
- CONFLATED 以为能保留历史序列:只保留最新一条。
追问
- BUFFERED 默认容量是多少?答:由库实现默认值决定,具体数值以版本文档为准(待确认)。
- 容量能在创建后调整吗?答:不能,容量策略在通道创建时固定。
04.8.2.2-023 Channel 溢出策略 BufferOverflow 有哪些选项?
一句话结论
BufferOverflow 定义缓冲满时 send 的行为:SUSPEND 挂起等待空位、DROP_OLDEST 丢弃最旧元素腾位、DROP_LATEST 丢弃当前要发送的新元素;配合自定义容量使用。
概念解释
- SUSPEND:经典背压,生产者等待。
- DROP_OLDEST:类似 conflate,保最新队列。
- DROP_LATEST:保队列内已有值,拒收新值。
- 策略在通道构造时传入。
原理流程
- 通道按容量维持队列。
- send 时队列未满直接入队。
- 已满:SUSPEND 挂起;DROP_OLDEST 弹出旧值;DROP_LATEST 放弃新值。
- 消费者取走元素后队列释放槽位。
代码或图示
val ch = Channel<Int>(
capacity = 10,
onBufferOverflow = BufferOverflow.DROP_OLDEST
)
常见误区
- DROP_LATEST 与 DROP_OLDEST 语义记反:一个弃新一个弃旧。
- 对不能丢的任务用丢弃策略:会丢失业务事件,应 SUSPEND 反压。
追问
- 溢出策略与 CONFLATED 容量关系?答:CONFLATED 等价保最新的丢弃最旧语义。
- 丢弃事件如何感知?答:策略不返回丢弃通知,需要监控队列长度或指标。
04.8.2.2-024 Channel 关闭与 isClosedForSend、isClosedForReceive 有何区别?
一句话结论
close() 标记通道为发送关闭:不再允许 send,已入队元素仍可被接收完;isClosedForSend 表示发送侧关闭,isClosedForReceive 在队列排空且发送关闭后为 true;两侧状态分离,避免提前误判无数据。
概念解释
- 关闭是通知结束,不删队列残留。
- 发送关闭后消费者可取完积压值。
- 两个布尔属性分别反映两侧状态。
原理流程
- 生产者调用 close,发送侧置关闭。
- 已入队元素继续被 receive 取走。
- 队列空且发送关闭,接收侧置关闭。
- 消费者遍历通道时收到结束信号退出循环。
代码或图示
channel.close()
while (!channel.isClosedForReceive) {
println(channel.receiveCatching().getOrNull())
}
常见误区
- close 后还 send:会抛异常。
- 刚 close 就读 isClosedForReceive 为 true:积压未排空前仍为 false。
追问
- 异常结束通道怎么处理?答:随协程取消终止,残留值按取消语义丢弃/处理。
- 遍历通道的推荐写法?答:
for (value in channel)或 consumeEach,结束信号自动退出。
04.8.2.2-025 produce 构建器返回什么,解决什么问题?
一句话结论
produce 在协程作用域内创建一个生产者 Channel,返回 ReceiveChannel;它把「启动一个协程往通道发数据」封装起来,适合基于通道的事件流;现代代码中很多场景可由 Flow/channelFlow 替代。
概念解释
- produce 是 Channel 消费者友好的启动器。
- 返回接收通道,支持迭代与 receiveCatching。
- 生产者协程随作用域结构化管理。
原理流程
- produce 在作用域内启动生产者协程。
- 块内 send 元素到内部通道。
- 返回 ReceiveChannel 给消费方。
- 作用域取消时生产者与通道一并终止。
代码或图示
val channel = scope.produce {
repeat(3) { send(it) }
}
channel.consumeEach { println(it) }
常见误区
- 把返回通道当热流长期共享:produce 绑定单次收集关系,多订阅语义弱于 SharedFlow。
- 不随作用域取消生产者:通道与协程可能泄漏。
追问
- produce 与 channelFlow 怎么选?答:需要通道原语/多生产者用 produce 或 channelFlow;普通数据流优先 Flow 操作符。
- consumeEach 是否废弃?答:相关 Channel 消费 API 存在演进,以当前版本文档标注为准(待确认)。
04.8.2.2-026 actor 构建器的角色与现状是什么?
一句话结论
actor 把状态封装在单协程内,通过接收消息 Channel 串行处理,避免显式锁;它是经典 actor 模型在协程上的实现,部分 API 状态随版本演进,新项目中可变状态封闭到单调度器或用 Mutex 也是常见替代,具体废弃标注以当前文档为准(待确认)。
概念解释
- actor 模型:消息串行驱动私有状态。
- 避免多线程直接改共享变量。
- 与 Channel 双向通道配合。
原理流程
- actor 启动单协程持有私有状态。
- 外部向其发送消息到通道。
- 协程串行接收并更新状态。
- 状态访问全部经消息队列,天然互斥。
代码或图示
// actor 风格:单协程串行处理消息,避免共享可变状态
val actor = scope.actor<Msg> {
for (msg in channel) state.handle(msg)
}
常见误区
- 在 actor 协程内再并发改状态:破坏串行封闭。
- 把 actor 当通用高并发原语:它适合串行状态封装,不适合高吞吐并行。
追问
- actor 与 Mutex 怎么选?答:消息驱动状态封装选 actor;简单临界区互斥选 Mutex。
- 当前版本 actor API 是否废弃?答:查 kotlinx.coroutines 文档与 Deprecated 注解确认。
04.8.2.2-027 Channel 的 consumeEach 与 receive 循环怎么取舍?
一句话结论
consumeEach 遍历通道元素到结束,处理完消费通道;receive/receiveCatching 手动取下一个值,可在循环中做条件退出与错误处理;旧的 consumeEach 写法在新版本可能有废弃演进,优先以文档推荐的迭代方式为准(待确认)。
概念解释
- 遍历接收:for 循环或 consumeEach。
- 手动接收:receiveCatching 处理空与关闭。
- 通道消费关系影响能否复用通道。
原理流程
- 消费者进入遍历循环。
- 每取一个元素处理。
- 通道关闭排空后循环退出。
- receiveCatching 返回 Result,getOrNull 处理结束。
代码或图示
for (value in channel) {
handle(value)
}
// 或
while (true) {
val result = channel.receiveCatching()
if (result.isClosed) break
handle(result.getOrThrow())
}
常见误区
- 手动 receive 不判断关闭:结束后可能抛异常。
- 复用已被 consume 的通道:消费语义决定通道归属。
追问
- receiveCatching 相比 receive 优势?答:关闭与异常封装为 Result,避免直接抛通道关闭异常。
- 多消费者平分通道元素吗?答:通道元素被一个消费者取走,不广播给全部订阅者。
04.8.2.2-028 Channel 与队列的关键差别是什么?
一句话结论
Channel 是挂起式协程通信原语:满/空时协程挂起等待而非阻塞自旋,并随协程取消传播;普通线程队列阻塞等待与线程绑定,不感知协程生命周期;Channel 面向协程间消息传递与流式背压。
概念解释
- 挂起等待:不占线程。
- 取消传播:通道随作用域终止。
- 消息语义:发送/接收配对,可关闭通知结束。
原理流程
- 满通道 send 挂起当前协程,线程释放。
- 消费者取走元素,唤醒等待发送者。
- 协程取消时通道等待者一并取消。
- 线程队列则依赖锁阻塞唤醒机制。
代码或图示
suspend fun produce(channel: Channel<Int>) {
channel.send(1) // 满则挂起,不阻塞自旋
}
常见误区
- 用 Channel 替代所有线程安全集合:共享内存状态仍需其他同步手段。
- 以为通道满时忙等:默认 SUSPEND 是挂起等待。
追问
- 通道里能传可变对象引用吗?答:能,但接收方不应并发修改;优先传不可变值。
- 通道取消时残留元素怎么办?答:按取消语义丢弃,需要持久化应在通道外落盘。
04.8.2.2-029 SharedFlow 与 StateFlow 都是热流,核心区别是什么?
一句话结论
SharedFlow 是可配置重放缓存的通用热流,可多对多广播任意类型值;StateFlow 是持有单一状态值的特殊 SharedFlow,始终有当前值、value 可读、用 equals 去重,面向状态暴露。
概念解释
- SharedFlow:replay 缓存、自定义缓冲与溢出策略。
- StateFlow:current state、初始值、状态去重。
- 两者上游独立于订阅者存活。
原理流程
- SharedFlow 配置 replay 与缓冲,新订阅者先收缓存重放。
- 新值发给所有活跃订阅者。
- StateFlow 内部维护状态值,更新时去重后广播。
- 订阅关系不影响上游生产者存活。
代码或图示
val events = MutableSharedFlow<Event>(replay = 0)
val state = MutableStateFlow(UiState.Loading)
常见误区
- 把 StateFlow 当事件总线:状态流每次新订阅都拿到当前状态,不适合一次性事件。
- 以为 SharedFlow 必须有初始值:replay=0 时无初始值。
追问
- StateFlow 与 SharedFlow 结构关系?答:StateFlow 是在 SharedFlow 基础上约束单值状态的特化(版本实现细节以官方文档为准)。
- 事件总线选哪个?答:一次性事件用 replay=0 的 SharedFlow;页面状态用 StateFlow。
04.8.2.2-030 SharedFlow 的 replay 缓存如何工作?
一句话结论
replay 表示给新订阅者立即重放的最近元素个数:新订阅者先收到缓存中的历史值,再接收后续新值;replay=0 只收订阅之后的新值,缓存容量与 replay 共同决定保留多少历史。
概念解释
- replay 面向新订阅者的历史补偿。
- 缓存满后按溢出策略淘汰旧值。
- 状态流需要最新快照,事件流通常 replay=0。
原理流程
- MutableSharedFlow 构造时指定 replay 与缓冲。
- 新值写入缓存与广播列表。
- 新订阅者订阅时先重放 replay 个最近值。
- 之后接收实时新值。
代码或图示
val bus = MutableSharedFlow<Event>(replay = 2, extraBufferCapacity = 4)
常见误区
- replay 设很大存全量历史:内存持续增长。
- 用 replay 缓存一次性点击事件:新页面订阅会重复收到旧事件。
追问
- extraBufferCapacity 与 replay 关系?答:replay 是重放缓存,extra 是实时缓冲槽位,两者共同构成容量。
- 缓存淘汰策略可配吗?答:SharedFlow 有 BufferOverflow 配置(选项以版本文档为准,待确认)。
04.8.2.2-031 stateIn 与 shareIn 把冷流转热流时各做什么?
一句话结论
stateIn 把冷 Flow 转为持有状态的 StateFlow,需要作用域、初始值与启动策略;shareIn 把冷 Flow 转为 SharedFlow,配置 replay 与订阅启动策略;两者让上游在共享作用域内独立于个别订阅者运行。
概念解释
- stateIn:聚合为单一状态,可直接读 value。
- shareIn:广播流,可配置重放。
- 启动策略:懒订阅开始、首个订阅开始或立即开始。
原理流程
- 指定上游冷流与共享 Scope。
- stateIn 维护状态值,shareIn 维护缓存与订阅者。
- 按启动策略订阅上游。
- 上游在共享 Scope 内运行,值分发给订阅者。
代码或图示
val state = source.stateIn(scope, SharingStarted.Lazily, UiState.Idle)
val shared = source.shareIn(scope, SharingStarted.Eagerly, replay = 1)
常见误区
- 不传合适 Scope:上游生命周期不明确,易泄漏。
- 对一次性事件用 stateIn:状态去重与重放会重复投递旧状态。
追问
- SharingStarted 有哪些策略?答:Eagerly、Lazily、WhileSubscribed 等(具体行为以版本文档为准,待确认)。
- stateIn 上游异常如何传播?答:进入 StateFlow 状态/失败路径,按配置与订阅者处理。
04.8.2.2-032 StateFlow 的值更新为什么推荐用 update?
一句话结论
MutableStateFlow.update { } 以当前值为基础原子计算新值,避免多协程并发读改写造成丢失更新;直接读 value 再写回在并发下不是复合原子操作,复杂状态更新应走 update 或 compareAndSet。
概念解释
- 状态更新是读-改-写复合操作。
- update 在内部保证基于最新值计算。
- 相等的新值不会触发新的广播。
原理流程
- update lambda 接收当前状态。
- 返回新状态,内部 CAS 尝试更新。
- 冲突时重试读取最新值重算。
- 新值与旧值相等则不通知订阅者。
代码或图示
state.update { current -> current.copy(loading = false) }
常见误区
- 并发
state.value = state.value.copy(...):读改写交错丢失更新。 - 在 update lambda 里做副作用或阻塞:lambda 应纯计算。
追问
- compareAndSet 与 update 关系?答:CAS 是底层原子比较设置,update 封装重试与计算。
- StateFlow 去重依据什么?答:新值与当前值 equals 相等则不发射。
04.8.2.2-033 StateFlow 新订阅者会收到什么?
一句话结论
StateFlow 新订阅者立即收到当前最新状态值,之后才收到后续更新;它永远有一个当前值,这与 replay=0 的 SharedFlow(只收订阅后事件)形成对比,也是状态流适合 UI 状态、不适合一次性事件的原因。
概念解释
- 初始/最新状态总是先投递。
- 状态去重避免重复相同快照。
- 历史事件不在 StateFlow 中保留多条。
原理流程
- 订阅者连接到 StateFlow。
- 立即发射当前 value。
- 后续状态更新按 equals 比较发射。
- 无新值时订阅者不被重复唤醒。
代码或图示
viewModel.state.collect { screen -> render(screen) }
// 进入收集即拿到当前状态
常见误区
- 用 StateFlow 发「点击后跳转」这类事件:重新进入页面/重复订阅会再次收到旧状态。
- 以为订阅前更新的历史都能收到:只有当前快照,不是历史序列。
追问
- 一次性事件用什么承载?答:SharedFlow(replay=0) 或单向事件通道。
- 状态与事件如何共存?答:StateFlow 放界面状态,SharedFlow 放单次事件。
04.8.2.2-034 SharedFlow 订阅者数量与上游有什么关系?
一句话结论
SharedFlow 上游是否运行取决于启动策略:WhileSubscribed 在有订阅者时启动、全部退出后停止;Eagerly/Lazily 按策略在作用域内常驻;订阅者数量变化只影响广播分发,不改变冷流上游在未共享前的执行次数。
概念解释
- 共享上游独立于个别订阅者。
- 订阅计数驱动条件启动策略。
- 作用域取消时上游终止。
原理流程
- shareIn 指定 SharingStarted 与 Scope。
- 订阅者增减更新计数。
- WhileSubscribed 按计数上下线上游。
- 上游值分发给所有活跃订阅者。
代码或图示
val shared = source.shareIn(
scope,
SharingStarted.WhileSubscribed(stopTimeoutMillis = 2000),
replay = 1
)
常见误区
- 以为每个订阅者都重跑一遍上游:共享模式下上游只有一份。
- 以为订阅者退出会清空 replay 缓存:缓存按配置保留。
追问
- WhileSubscribed 超时停止的作用?答:全部订阅退出后延迟停止上游,避免频繁上下线抖动(超时参数以版本为准)。
- 多订阅者收到值顺序一致吗?答:按广播顺序分发,各订阅者处理节奏独立。
04.8.2.2-035 热流的取消与生命周期由谁管理?
一句话结论
热流的生产者生命周期由创建时传入的 CoroutineScope 管理:Scope 取消则上游终止、流结束;单个订阅者取消只断开自己的收集,不停止共享上游;状态/事件流在组件销毁时随 Scope 一起取消。
概念解释
- 热流不依附单次 collect。
- 上游 Job 挂在共享 Scope 下。
- 订阅者取消是局部断开。
原理流程
- stateIn/shareIn 使用传入 Scope 启动上游。
- 订阅者 collect 取消只停止自己的收集协程。
- Scope.cancel() 取消上游 Job,流广播结束。
- SharedFlow 缓存随上游生命周期释放。
代码或图示
// viewModelScope 销毁时自动取消共享上游
val state = source.stateIn(viewModelScope, SharingStarted.Lazily, idle)
常见误区
- 取消一个 collect 就以为上游停了:共享上游继续服务其他订阅者。
- 用 GlobalScope 持有热流:生命周期脱离页面/应用边界。
追问
- 上游异常后热流还能继续吗?答:上游失败终止流,需重建共享实例或重试设计。
- 组件销毁如何释放订阅?答:在生命周期作用域内 collect,取消随销毁自动传播。
04.8.2.2-036 buffer 指定容量后上下游如何交换元素?
一句话结论
buffer(capacity) 在上下游间建指定容量的通道:上游把元素 send 到通道,下游从通道取;通道未满时上下游可并行推进,满了上游按默认 SUSPEND 背压等待,容量决定排队上限。
概念解释
- 容量是通道槽位数,不是历史重放缓存。
- 上下游解耦后在不同协程中运行。
- 溢出行为可通过通道策略配置。
原理流程
- buffer 创建容量为 n 的通道。
- 上游协程 send 入队。
- 下游协程 receive 出队处理。
- 队满上游挂起,队空下游挂起,随消费/生产唤醒。
代码或图示
source.buffer(16).collect { process(it) }
常见误区
- 以为 buffer 容量越大越快:过大占内存,且不能突破下游处理能力。
- buffer 与 replay 混淆:buffer 是运行期排队,replay 是热流订阅重放。
追问
- 不指定容量的 buffer 用什么策略?答:使用库默认缓冲配置,具体默认值以版本文档为准(待确认)。
- 多个 buffer 串联会叠加队列吗?答:相邻缓冲操作符各自建通道,容量分段累加。
04.8.2.2-037 下游处理慢时,缓冲、合并、最新值三种策略如何选?
一句话结论
不能丢且要求完整顺序用 buffer(配合背压);允许丢弃中间过程、只保留最新快照用 conflate;每次都要对最新值重新发起异步处理用 collectLatest;按「能否丢值、是否保序、可否取消旧任务」三个维度选型。
概念解释
- buffer:完整保留,排队等待。
- conflate:保最新,不取消进行中的下游处理。
- collectLatest:可取消旧处理,切换到最新任务。
原理流程
- 评估业务:事件不可丢选 buffer。
- 中间状态可覆盖选 conflate。
- 旧任务结果无价值且可中断选 collectLatest。
- 监控队列长度与丢弃情况验证策略。
代码或图示
source.buffer(32).collect { persist(it) }
source.conflate().collect { refreshSnapshot(it) }
source.collectLatest { fetchLatest(it) }
常见误区
- 支付/订单事件用丢弃策略:业务事件不能丢,应缓冲或持久化。
- 在 collectLatest 里做必须完整提交的事务:被取消会留下半成品。
追问
- 队列积压多久该告警?答:按 SLA 设队列长度与等待时间阈值。
- 丢值策略需要补偿吗?答:关键状态可由最新快照/定期同步兜底。
04.8.2.2-038 Flow 中 drop 类操作符与通道丢弃策略是什么对应关系?
一句话结论
Flow 侧的 conflate 对应通道 DROP_OLDEST 保最新语义;操作符层没有通用 DROP_LATEST 的便捷等价物,需要时可用 channelFlow 自建通道与溢出策略;理解映射有助于在操作符与通道原语间转换。
概念解释
- conflate 内部使用合并最新的通道语义。
- DROP_LATEST 保队列旧值、拒新值,业务少见。
- 自定义丢弃逻辑可在 channelFlow 内实现。
原理流程
- conflate 通道只保留最新元素。
- 新值覆盖旧值,下游取最新。
- DROP_LATEST 场景需自建通道策略。
- 丢弃决定在生产者入队时做出。
代码或图示
// 保最新:conflate
source.conflate()
// 自定义策略:channelFlow + Channel 配置
channelFlow { /* send 配合自定义通道策略 */ }
常见误区
- 以为所有通道策略都有同名 Flow 操作符:并非一一对应。
- 依赖操作符内部队列行为做精确时序假设:版本实现可能调整。
追问
- 如何观测被丢弃的元素?答:在自定义通道/操作符内计数埋点,操作符本身不返回丢弃通知。
- conflate 的重放语义?答:它不跨订阅重放,仍是冷流。
04.8.2.2-039 生产速率远高于消费速率时如何防止内存膨胀?
一句话结论
先评估能否降产(限流、采样、合并),再设置有界缓冲与明确溢出策略;关键事件落库或持久化队列后异步消费;避免 UNLIMITED 缓冲与无界 replay,监控队列长度并在背压超阈值时降级。
概念解释
- 内存膨胀来自无界排队的元素对象。
- 降产:上游只产出必要粒度。
- 持久化:不可丢事件先落盘再消费。
原理流程
- 统计生产/消费速率差与单元素大小。
- 设有界缓冲与溢出策略。
- 关键事件持久化兜底。
- 队列超阈值触发限流或降级,避免 OOM。
代码或图示
source.buffer(100, BufferOverflow.DROP_OLDEST)
.collect { consume(it) }
常见误区
- 用 UNLIMITED 通道「先接住再说」:流量峰值时内存失控。
- 只调大缓冲不提升消费能力:只是把崩溃推迟。
追问
- 消费慢的根因怎么定位?答:拆解下游各阶段耗时,区分 IO、计算、锁等待与线程池排队。
- 跨进程/分布式背压怎么做?答:通道只解决进程内,跨进程需队列中间件与消费速率控制。
04.8.2.2-040 channelFlow 与普通 flow {} 在并发发射上的约束差异是什么?
一句话结论
普通 flow {} 的收集器要求串行 emit,不能从多个协程并发调用;channelFlow 内部带通道,可在块内 launch 多个并发生产者协程并发 send,最后用 awaitClose 清理,适合多源并发汇聚。
概念解释
- flow{}:单收集器顺序契约。
- channelFlow:通道解耦并发发送。
- 两者都是冷流,订阅时激活。
原理流程
- channelFlow 创建内部通道与收集作用域。
- 块内启动多个子生产者 send 到通道。
- 通道值串行交给下游。
- 流取消时子生产者随作用域终止,awaitClose 执行清理。
代码或图示
channelFlow {
launch { send(fetchA()) }
launch { send(fetchB()) }
awaitClose { unsubscribe() }
}
常见误区
- 在 flow{} 里 launch 后并发 emit:违反串行契约,行为不可靠。
- channelFlow 不写 awaitClose:订阅取消后回调订阅可能不释放。
追问
- channelFlow 默认缓冲策略?答:使用通道默认配置,可在构建参数指定容量与溢出策略(参数以版本为准,待确认)。
- 并发 send 的顺序保证?答:不保证各生产者先后,按到达通道顺序发射。
04.8.2.2-041 callbackFlow 桥接回调 API 时必须处理什么?
一句话结论
callbackFlow 把基于回调的 API 接入 Flow:在块内注册回调并 trySend 元素,用 awaitClose 在流取消/关闭时反注册回调;不写 awaitClose 会导致订阅取消后回调仍持有引用、资源泄漏。
概念解释
- callbackFlow 是 channelFlow 的回调特化。
- 回调线程与协程线程不同,经通道转交。
- 反注册是取消路径上的必要清理。
原理流程
- 块内注册监听器到旧式回调 API。
- 回调到达时 trySend 元素到通道。
- 订阅取消,awaitClose 回调执行反注册。
- 通道关闭,流结束。
代码或图示
fun locationFlow(): Flow<Location> = callbackFlow {
val listener = onUpdate { loc -> trySend(loc) }
register(listener)
awaitClose { unregister(listener) }
}
常见误区
- 省略 awaitClose:取消后监听器仍触发,持有上下文引用。
- 在回调里直接操作协程外状态:应把值经通道交给下游处理。
追问
- trySend 满了怎么办?答:按通道溢出策略处理;需要背压等待用 send(挂起)。
- 回调报错如何进入流?答:trySend 异常结果或 close(exception),下游 catch 感知。
04.8.2.2-042 awaitClose 什么时候被调用?
一句话结论
awaitClose 注册的清理回调在通道关闭或流被取消时调用:订阅者取消、上游完成、通道异常关闭都会触发;它是 callbackFlow/channelFlow 释放外部订阅、句柄的标准位置,不在元素流路径上执行。
概念解释
- 清理回调在流终态触发。
- 可能在任意线程执行。
- 多次订阅各自注册与清理配对。
原理流程
- 生产者块注册 awaitClose 动作。
- 流正常结束或取消。
- 通道关闭,触发清理回调。
- 反注册外部回调、释放资源。
代码或图示
callbackFlow {
val sub = observe()
awaitClose { sub.dispose() }
}
常见误区
- 把业务值发射放进 awaitClose:它只做清理,不发射元素。
- 假设 awaitClose 在订阅者线程执行:线程由关闭触发上下文决定。
追问
- 流正常完成还会调 awaitClose 吗?答:会,关闭路径统一触发清理。
- 清理动作需要挂起怎么办?答:回调内不能直接挂起,可用独立不可取消作用域完成必要释放。
04.8.2.2-043 Flow 取消如何从 collect 传播到上游回调?
一句话结论
collect 协程取消时取消信号沿操作符链到达 channelFlow/callbackFlow 作用域,块内子生产者随之取消,awaitClose 执行反注册;旧式回调 API 若不支持主动反注册,需在回调到达时检查流是否已关闭并丢弃值。
概念解释
- 取消沿父子 Job 链与流链双向传播。
- 桥接层要把协程取消映射为外部订阅释放。
- 已取消通道的 send 不会再到下游。
原理流程
- 收集协程被 cancel。
- 链上各操作符响应取消。
- channelFlow 子生产者取消,awaitClose 反注册。
- 迟到的回调检查通道关闭状态,丢弃结果。
代码或图示
callbackFlow {
val listener = onEvent { value ->
if (isClosedForSend) return@onEvent
trySend(value)
}
awaitClose { remove(listener) }
}
常见误区
- 桥接层不检查取消:取消后回调仍更新已销毁页面。
- 反注册异步且不等待:旧回调可能在反注册完成前到达。
追问
- 如何判断通道是否关闭?答:读
isClosedForSend,或在 send 结果中判断通道状态。 - 外部 API 无反注册接口怎么办?答:保留弱引用与关闭标记,回调中检查后丢弃并尽快释放引用。
04.8.2.2-044 select 在多通道等待时解决什么问题?
一句话结论
select 可同时挂起等待多个 Channel/Deferred,哪个先就绪就处理哪个并返回对应结果;用于多路复用等待,避免为每个通道单独起协程轮询,在多个异步源间取最先完成的事件。
概念解释
- select 是挂起式多路等待原语。
- 就绪分支执行对应 action。
- 配合通道 receive 或 Deferred await 使用。
原理流程
- 注册多个等待分支到 select。
- 任一通道有值/Deferred 完成,分支就绪。
- select 选择先就绪分支执行。
- 返回分支结果,其余分支取消等待。
代码或图示
select<Result> {
channelA.onReceive { a -> Result.A(a) }
channelB.onReceive { b -> Result.B(b) }
}
常见误区
- 用多个独立协程轮询合并通道:复杂且难管理取消,select 更直接。
- 在 select 分支里做长阻塞:会延迟其他分支就绪响应。
追问
- select 与 Flow 合并操作符关系?答:多 Flow 合并优先用 merge/combine;通道原语多路等待用 select。
- select 相关 API 在版本中是否有演进?答:以当前 kotlinx.coroutines 文档为准,旧接收扩展可能标记废弃(待确认)。
04.8.2.2-045 通道 send 与 trySend 的区别是什么?
一句话结论
send 是挂起函数:通道满时挂起等待空位,按 SUSPEND 背压;trySend 是非挂起尝试入队,立即返回 ChannelResult(成功、已满、关闭等状态),适合回调线程或不能挂起的上下文做非阻塞投递。
概念解释
- send:挂起等待,保证背压语义。
- trySend:非阻塞探测,结果状态需判断。
- 关闭通道后两者都返回关闭结果。
原理流程
- send 检查通道容量,满则挂起注册等待。
- trySend 立即尝试入队,返回结果对象。
- 消费者取走元素唤醒等待 send。
- 关闭后 send 抛/返回关闭异常路径,trySend 返回关闭结果。
代码或图示
val result = channel.trySend(value)
if (result.isFailure) { /* 已满或关闭 */ }
常见误区
- 回调线程里调 send 挂起:回调线程不应被挂起长时间占用,应用 trySend。
- 忽略 trySend 结果:满/关闭时元素被丢弃而无感知。
追问
- trySend 成功等于被消费吗?答:只表示入队成功,不代表下游已处理。
- 结果对象有哪些状态?答:成功、已满、关闭等,具体枚举以版本文档为准(待确认)。
04.8.2.2-046 receiveCatching 相比 receive 解决什么问题?
一句话结论
receiveCatching 把接收结果封装为 ChannelResult:正常取值、通道关闭或失败都以结果形式返回,避免直接 receive 在关闭/异常时抛异常打断循环;适合稳健地遍历通道结束。
概念解释
- receive:有值返回,关闭时抛异常。
- receiveCatching:Result 风格,可 getOrNull/getOrThrow。
- 用于循环判断通道是否排空关闭。
原理流程
- 消费者调 receiveCatching。
- 有值返回成功结果。
- 通道关闭返回关闭结果。
- 循环用 isClosed 或 getOrNull 判断退出。
代码或图示
while (!channel.isClosedForReceive) {
val result = channel.receiveCatching()
result.getOrNull()?.let { handle(it) }
}
常见误区
- 直接 receive 不处理关闭异常:循环在通道结束时崩溃。
- 把关闭结果当失败业务错误:关闭是正常结束信号。
追问
- ChannelResult 如何取值?答:
getOrNull()、getOrThrow(),并判断isClosed。 - 多消费者通道关闭时各自都会收到关闭结果吗?答:通道关闭信号对所有接收者生效。
04.8.2.2-047 多个协程从同一通道接收,元素如何分配?
一句话结论
通道元素被竞争消费:一个元素只被一个接收协程取走,多个消费者平分通道中的元素(负载分摊),不是广播给每个消费者;需要广播给多个订阅者应使用 SharedFlow 或为每个订阅者建独立通道。
概念解释
- 通道是工作队列语义,不是发布订阅。
- 多个 receive 协程竞争空闲元素。
- 分发顺序与消费者等待状态有关。
原理流程
- 元素入队或等待接收者。
- 多个接收协程注册等待。
- 一个元素唤醒一个接收者。
- 其余继续等待下一元素。
代码或图示
repeat(4) {
scope.launch { while (true) handle(channel.receive()) }
}
常见误区
- 用普通 Channel 做事件广播:每个订阅者收不到完整副本。
- 期待固定轮询分配:实际按唤醒竞争顺序。
追问
- 想每个订阅者独立收全量怎么做?答:SharedFlow 广播,或 produce 为每个订阅者创建独立通道。
- 多消费者如何保证任务不重复?答:通道元素一旦被取走即移除,消费方幂等兜底。
04.8.2.2-048 Channel 的「 rendezvous(会合)」语义在什么场景有用?
一句话结论
RENDEZVOUS 零缓冲要求发送与接收配对才通过元素,发送者挂起直到接收者到达,适合严格的握手式任务交接、不允许排队积压的同步点;常规数据流通常需要缓冲或合并策略。
概念解释
- 零容量,无元素停留槽位。
- 发送接收直接配对传递。
- 上下游节奏被强制对齐。
原理流程
- send 时无等待接收者则挂起。
- 接收者到达,元素直接交接。
- 交接完成双方继续。
- 没有中间队列,不保存历史值。
代码或图示
val handoff = Channel<Work>(Channel.RENDEZVOUS)
常见误区
- 高频事件用 rendezvous:发送者大量挂起等待,吞吐受限。
- 以为会合通道能缓存突发流量:不能。
追问
- rendezvous 与 Unconfined 调度有关吗?答:无关,容量策略独立于调度器。
- 握手场景失败如何取消?答:通道随作用域取消,等待双方收到取消信号。
04.8.2.2-049 通道异常关闭与正常关闭在消费侧有何表现?
一句话结论
正常 close() 后消费者取完残留值再收到结束信号;带异常的关闭(close(throwable))让接收侧结果携带该异常,可在消费循环中识别并向上传播;通道关闭原因决定下游是正常结束还是失败收尾。
概念解释
- 正常关闭:结束无异常。
- 异常关闭:结束携带失败原因。
- receiveCatching 可读取关闭原因。
原理流程
- 生产者判断异常路径,close(cause)。
- 残留元素仍可被取走。
- 排空后接收结果携带 cause。
- 下游按 cause 决定上报或降级。
代码或图示
channel.close(IOException("network"))
// 消费侧
val result = channel.receiveCatching()
result.exceptionOrNull()?.let { report(it) }
常见误区
- 异常关闭后还期待继续收到业务值:残留取完即结束。
- 把关闭 cause 当普通业务异常忽略:可能是上游失败信号。
追问
- Flow 层如何把通道异常转成流异常?答:channelFlow 内 close(exception),下游 catch 捕获。
- 通道能重新打开吗?答:关闭后不可复用,需新建通道。
04.8.2.2-050 一个通道可以同时有多个发送协程吗?
一句话结论
可以:多个生产者协程可向同一通道并发 send/trySend,通道内部保证元素入队线程安全;元素被串行排队,消费者侧按到达顺序接收;多生产者汇聚适合用 channelFlow 统一管理取消与生命周期。
概念解释
- 通道并发发送是线程安全的。
- 多生产者共享一个接收队列。
- 生命周期需随统一作用域管理。
原理流程
- 多个生产者 launch 到同一作用域。
- 各自 send 元素到通道。
- 通道保证入队互斥与顺序排队。
- 消费者取走元素,作用域取消时生产者一并终止。
代码或图示
channelFlow {
repeat(3) { launch { send(produce(it)) } }
awaitClose { }
}
常见误区
- 多个生产者不挂同一作用域:取消时部分生产者悬空。
- 期望多生产者按固定优先级入队:通道不保证优先级,按到达顺序。
追问
- 通道容量对多生产者意义?答:限制聚合队列长度,满了按溢出策略反压。
- 多生产者异常如何汇总?答:各自异常进入通道关闭原因或结果包装,统一在消费侧处理。
04.8.2.2-051 为什么不推荐在普通代码里直接裸用 Channel 管理 UI 事件?
一句话结论
裸 Channel 是单次消费、需手动关闭与取消管理的原语;UI 事件广播、状态暴露更适合 StateFlow/SharedFlow:自带订阅管理、重放缓存与作用域绑定,直接裸用通道容易泄漏订阅、错过新订阅者初始值。
概念解释
- 通道:工作队列,元素只被消费一次。
- SharedFlow:多订阅广播,缓存策略可配。
- StateFlow:单一状态快照。
原理流程
- 识别需求:状态、广播事件还是任务队列。
- 状态用 StateFlow,广播用 SharedFlow。
- 通道保留给协程间任务交接与底层汇聚。
- 生命周期统一绑定页面作用域。
代码或图示
// UI 状态
val uiState = MutableStateFlow<UiState>(Idle)
// 一次性事件
val events = MutableSharedFlow<UiEvent>(replay = 0)
常见误区
- 用 Channel 做全局事件总线:新订阅者收不到历史,关闭与泄漏风险高。
- 把状态变更塞进普通 Channel:丢失当前快照,新订阅者无法恢复界面。
追问
- 什么时候仍该用 Channel?答:后台任务队列、多生产者汇聚、select 多路等待等底层原语场景。
- SharedFlow 替代 produce 的边界?答:需要广播/缓存用 SharedFlow;单次交接用通道。
04.8.2.2-052 produce 返回的通道多订阅行为有什么限制?
一句话结论
produce 返回的 ReceiveChannel 元素是单次消费语义:多个收集方竞争同一队列,不会给每个收集方完整副本;需要多订阅广播应改为 SharedFlow,否则第二个收集方只能捡到剩余元素。
概念解释
- 通道接收是竞争消费。
- produce 生命周期绑定其作用域。
- 多副本语义需共享流实现。
原理流程
- produce 启动生产者往通道发元素。
- 多个收集协程竞争 receive。
- 元素被一方取走,另一方不可见。
- 需要广播时上游改 SharedFlow 并 shareIn。
代码或图示
// 竞争消费:不是广播
val ch = scope.produce { send(1) }
常见误区
- 把 produce 通道当热流复用:订阅模型不匹配。
- 不取消 produce 协程:作用域泄漏。
追问
- produce 与 channelFlow 选择?答:需要 ReceiveChannel 句柄用 produce;需要 Flow 下游管道用 channelFlow。
- 通道消费后能重新投递吗?答:需手动重新入队,不支持自动重放。
04.8.2.2-053 Flow 操作符里哪些属于「末端收集」,哪些是「中间操作」?
一句话结论
返回 Flow<T> 的是中间操作(map/filter/buffer/flatMap 等),惰性拼接成管道;返回挂起结果或 Unit 的是末端收集(collect/toList/first/reduce/stateIn 触发订阅除外),只有末端操作才真正启动上游执行。
概念解释
- 中间操作不触发收集,只装饰管道。
- 末端操作启动协程运行上游。
- stateIn/shareIn 是转换为热流的特殊操作,按共享策略启动上游。
原理流程
- 链式调用中间操作,保存操作符包装。
- 末端 collect 启动收集协程。
- 上游沿链发射,逐级经过中间操作。
- 末端消费结果或汇聚。
代码或图示
source.map { it }.filter { it > 0 } // 中间,未执行
.collect { } // 末端,启动上游
常见误区
- 以为构造 Flow 链时就调起网络/数据库:惰性,末端订阅才执行。
- 同一 Flow 链调两次末端:上游跑两遍(冷流语义)。
追问
stateIn何时启动上游?答:按 SharingStarted 策略,不是每次 collect 启动。- 如何复用同一份上游结果?答:shareIn/stateIn 转为热流共享一份上游。
04.8.2.2-054 Flow 异常在操作符链中向上传播的顺序是怎样的?
一句话结论
异常从抛出节点沿收集器调用链向上回溯:先经过其上方的 catch/retry 等异常处理操作符,再到末端 collect 协程;下游操作符抛出的异常不会被上游方向的 catch 捕获,处理位置必须放在异常节点之前(链的上游侧)。
概念解释
- 链方向:上游产生值,向下游流动;异常反向回溯。
- catch 只拦自己上游的异常。
- 取消异常沿同一链传播但不应被重试吞掉。
原理流程
- 某操作符 lambda 抛异常。
- 回溯经过已包装的上层操作符。
- 遇到 catch 处理或放行。
- 到达 collect 协程,未处理则冒泡到作用域。
代码或图示
source.catch { /* 只捕获 source 与本 catch 上游异常 */ }
.map { /* 此处异常不被上面 catch 捕获 */ }
.collect { }
常见误区
- 把 catch 放在链首却想保护末端 map 异常:位置错误。
- retry 包住取消异常导致取消被重试复活。
追问
- 异常能在中间操作符转成兜底值吗?答:catch 内 emit 兜底值继续向下游。
- 多个 catch 嵌套如何生效?答:内层先处理,放行后外层继续捕获。
04.8.2.2-055 Flow 与 RxJava 式响应流在冷订阅模型上的对应关系是什么?
一句话结论
Flow 冷订阅、挂起式背压与 RxJava Observable 的冷订阅概念对应,但 Flow 直接使用协程取消与挂起点,背压通过通道/操作符表达;互操作时需要桥接转换订阅与取消,两套体系的调度器与线程模型不能直接混用。
概念解释
- 冷订阅:订阅才触发上游。
- 背压:Flow 挂起等待,RxJava 有自己的请求协议。
- 桥接:订阅生命周期与取消需双向映射。
原理流程
- 从 RxJava 源桥接为 Flow,订阅时建立上游订阅。
- 元素经桥接 send 到 Flow。
- Flow 取消时取消 RxJava 订阅。
- 反向转换同理,错误与取消相互映射。
代码或图示
// 互操作依赖对应桥接库;坐标与 API 以项目依赖版本为准(待确认)
rxSource.asFlow().collect { }
常见误区
- 把 RxJava Disposable 直接当协程 Job:取消模型不同。
- 桥接后不处理取消反注册:订阅泄漏。
追问
- 桥接库属于哪个 artifact?答:kotlinx.coroutines 提供的响应式桥接模块,具体坐标以官方文档为准。
- 迁移优先级?答:新代码优先 Flow,旧 RxJava 链路按需桥接。
04.8.2.2-056 consumeEach、actor 等旧 Channel API 在新版本中的定位如何?
一句话结论
kotlinx.coroutines 持续把消费范式从 Channel 直接操作引导到 Flow:部分 consumeEach、旧 actor 扩展与通道接收辅助函数被标记废弃或推荐替代;新代码优先 Flow 操作符与 SharedFlow,旧代码按 Deprecated 注解与官方迁移文档逐步替换(具体废弃清单以当前版本为准,待确认)。
概念解释
- 废弃不等于立即删除,编译可能给警告。
- 替代方向:通道消费 → Flow collect;actor 消息封闭 → 单调度器/Mutex 或 Flow 状态管理。
- 升级时逐项核对 Deprecated 说明。
原理流程
- 升级依赖后查看编译警告。
- 对照官方迁移说明替换 API。
- 行为差异用测试验证。
- 不凭记忆保留旧签名。
代码或图示
// 旧通道遍历写法逐步迁移到 Flow 收集
channel.consumeEach { handle(it) }
常见误区
- 照搬旧教程里的废弃扩展函数:警告累积且未来版本不可用。
- 不查版本直接断定某 API 废弃:以本项目依赖版本的 KDoc 为准。
追问
- 如何查废弃状态?答:IDE 标注、KDoc
@Deprecated与 changelog。 - 通道原语本身废弃了吗?答:Channel 核心 send/receive/close 仍保留,废弃的是部分高层消费辅助。
04.8.2.2-057 为什么现代代码倾向用 Flow 替代 produce + consumeEach?
一句话结论
Flow 提供完整的变换、组合、异常与背压操作符链,冷订阅与协程取消模型统一;produce + consumeEach 是通道式裸原语,组合与错误处理要手写,管道能力弱,因此数据处理管道优先 Flow。
概念解释
- Flow:声明式管道,操作符丰富。
- produce:通道句柄,手动管理消费循环。
- 两者底层都可落到通道,但 Flow 抽象更高。
原理流程
- 数据需求为管道变换:选 Flow 操作符。
- 需要通道原语多路等待:保留 Channel。
- produce 仅在需要 ReceiveChannel 句柄时使用。
- 订阅、取消、异常统一走协程体系。
代码或图示
source.map { it }.filter { it > 0 }.collect { }
常见误区
- 每个简单循环都包一层 produce:过度使用底层原语。
- 在通道消费循环里手写 map/filter:重复造轮子且易漏异常处理。
追问
- 什么场景通道仍不可替代?答:select 多路复用、精确容量/溢出策略、actor 消息队列。
- Flow 能暴露通道句柄吗?答:必要时 channelFlow 内部用通道,对外仍是 Flow。
04.8.2.2-058 MutableSharedFlow 与只读 SharedFlow 如何暴露?
一句话结论
内部持有 MutableSharedFlow,对外暴露只读 SharedFlow 接口:外部只能 collect 不能 trySend,写入方法限制在生产者类内;同理 MutableStateFlow 对外暴露 StateFlow,封装写入边界。
概念解释
- 可变接口与只读接口分离。
- 防止外部随意发射破坏状态不变量。
- 写入集中在单一生产者或经 update 方法。
原理流程
- 类内创建 MutableSharedFlow/MutableStateFlow。
- 属性类型声明为只读 SharedFlow/StateFlow。
- 内部方法调 trySend/update 写入。
- 外部订阅只读观察。
代码或图示
class Repository {
private val _events = MutableSharedFlow<Event>()
val events: SharedFlow<Event> = _events
fun publish(e: Event) = _events.trySend(e)
}
常见误区
- 直接把 Mutable 类型暴露给 UI 层:外部可篡改状态。
- 多个外部类直接写入同一 MutableStateFlow:状态一致性难维护。
追问
- StateFlow 写入为什么用 update?答:并发读改写需要原子更新,见状态更新题。
- SharedFlow 多生产者写入允许吗?答:允许,但要明确写入边界与并发规则。
04.8.2.2-059 subscriptionCount 有什么用途?
一句话结论
MutableSharedFlow.subscriptionCount 是当前活跃订阅者数量的 StateFlow,可用于判断是否有人订阅、配合 WhileSubscribed 策略上下线上游,或在无订阅时暂停昂贵的生产逻辑;StateFlow 也可读取订阅状态用于资源管理。
概念解释
- 订阅计数随 collect 连接/断开增减。
- 可作为条件启动/停止上游的依据。
- 计数本身是只读状态流。
原理流程
- 订阅者连接,计数 +1。
- 订阅断开,计数 -1。
- 观察计数判断是否需要保活上游。
- 无订阅时释放昂贵资源。
代码或图示
shared.subscriptionCount.collect { count ->
if (count == 0) releaseHeavySource()
}
常见误区
- 把计数当永久在线标志:配置变更/短暂断开会归零再恢复。
- 无订阅时直接销毁共享实例:可能马上又有新订阅者。
追问
- WhileSubscribed 是否内部就用订阅计数?答:其策略基于订阅计数与超时管理,实现细节以官方文档为准。
- 计数为 0 时 replay 缓存还在吗?答:缓存按 SharedFlow 配置保留,不随订阅清空。
04.8.2.2-060 resetReplayCache 在什么场景需要?
一句话结论
MutableSharedFlow.resetReplayCache() 清空重放缓存,用于需要丢弃历史快照、避免新订阅者收到过期状态的场景(如登出后清理上一次会话事件);StateFlow 没有等价的清空 replay 概念,它始终持有当前状态。
概念解释
- replay 缓存是新订阅者的历史补偿。
- 切换账号/会话时旧缓存不应带到新上下文。
- 清空只影响缓存,不影响活跃订阅者已收到的元素。
原理流程
- 会话失效,调用 resetReplayCache。
- 重放队列清空。
- 新订阅者只收到清空后的新值。
- 活跃订阅者继续接收实时值。
代码或图示
fun logout() {
events.resetReplayCache()
}
常见误区
- 用 resetReplayCache 停止上游生产:它只清缓存,不取消生产者作用域。
- 对 StateFlow 调用等价清空:状态值需重新赋值为初始状态。
追问
- 缓存清空后 replay 配置还在吗?答:配置不变,后续新值重新进入缓存。
- 登出时是否也要取消上游?答:是,按生命周期取消共享 Scope,缓存清理与上游释放分别处理。
04.8.2.2-061 StateFlow 为什么会自动去重,去重依据什么?
一句话结论
StateFlow 发射新值时与当前值用 equals 比较,相等则不更新、不通知订阅者;去重依据是元素相等性,复杂数据类应正确实现 equals(data class 自动生成),引用相等但内容不同的对象需注意比较逻辑。
概念解释
- 状态流只关心当前快照是否变化。
- 重复相同状态避免无意义 UI 刷新。
- 可变对象不实现 equals 可能去重失效或误判。
原理流程
- 写入新状态值。
- 内部与当前 value 比较 equals。
- 相等:丢弃,不广播。
- 不等:更新 value 并通知订阅者。
代码或图示
data class UiState(val loading: Boolean, val list: List<Item>)
state.update { it.copy(loading = false) }
常见误区
- 用可变列表直接塞进 StateFlow:equals 不可靠,状态引用变化但内容相同可能反复刷新。
- 自定义类不实现 equals:默认引用比较,相同内容被当不同状态。
追问
- 列表内容变化如何触发更新?答:复制为新不可变列表放入新状态对象。
- 想强制每次都发射用什么?答:SharedFlow 不做状态去重,适合事件序列。
04.8.2.2-062 用 StateFlow 表达一次性界面事件为什么不合适?
一句话结论
StateFlow 始终持有当前状态,新订阅者会先收到当前值,配置变更或重复订阅时旧事件被再次消费,造成重复跳转/弹窗;一次性事件(导航、Toast、单条提示)应用 replay=0 的 SharedFlow 或事件通道。
概念解释
- 状态可重放,事件只应消费一次。
- 订阅恢复需要当前快照,事件不需要历史。
- 两类模型不可互相替代。
原理流程
- 事件发生写入事件通道 SharedFlow(replay=0)。
- 活跃订阅者收到一次。
- 后续新订阅者不收历史事件。
- 界面状态另存 StateFlow 供恢复。
代码或图示
private val _events = MutableSharedFlow<NavigationEvent>(replay = 0)
val events: SharedFlow<NavigationEvent> = _events
常见误区
- 把「点击跳转」放 StateFlow:旋转屏幕后重新订阅重复跳转。
- 事件加标记已消费:状态流模型下不可靠,应换事件流。
追问
- 事件需要持久化到状态吗?答:事件处理后把结果写入 StateFlow,事件本身走 SharedFlow。
- 多页面共享事件用什么?答:应用级 SharedFlow,配合生命周期订阅与 replay=0。
04.8.2.2-063 stateIn 的初始值与上游首次发射前,订阅者看到什么?
一句话结论
stateIn 需要显式初始值:上游尚未发射第一个状态前,StateFlow 持有初始值并先投递给订阅者;上游产生第一个值后覆盖初始状态,订阅者据此渲染加载中/默认界面,避免空状态。
概念解释
- StateFlow 必须有当前值,不能空。
- 初始值表达加载前默认界面。
- 上游失败时状态如何呈现取决于错误处理设计。
原理流程
- stateIn 指定初始值与 Scope。
- 订阅者先收到初始值。
- 上游发射状态,更新当前值。
- 后续订阅者收到最新快照。
代码或图示
val uiState = source.stateIn(
scope,
SharingStarted.Lazily,
UiState.Loading
)
常见误区
- 不设合理初始值:界面首次渲染状态缺失。
- 把初始值当永久兜底:上游成功后会被覆盖。
追问
- 上游异常后状态停在哪?答:按 catch/onCompletion 映射为错误状态写入 StateFlow,或保留上一状态。
- stateIn 冷启动策略选哪个?答:按页面是否需要立即加载选 Lazily/Eagerly/WhileSubscribed,具体策略语义以版本为准。
04.8.2.2-064 SharedFlow 的 extraBufferCapacity 与 replay 如何配合?
一句话结论
replay 是留给新订阅者重放的最近元素数,extraBufferCapacity 是实时事件在通道中的额外缓冲槽位;两者共同构成总缓冲,replay 缓存长期保留,extra 槽位服务于生产消费速率差,配置时分别按历史补偿与排队需求估算。
概念解释
- replay:跨订阅历史。
- extraBufferCapacity:运行期排队缓冲。
- 总容量影响内存占用。
原理流程
- 新值先写入缓冲。
- replay 部分保留供新订阅重放。
- extra 槽位缓解瞬时速率差。
- 满后按溢出策略处理。
代码或图示
MutableSharedFlow<Event>(
replay = 1,
extraBufferCapacity = 64
)
常见误区
- 只调 replay 解决消费慢:replay 不承担实时排队背压。
- 容量估算忽略单元素大小:高频大对象仍可能 OOM。
追问
- replay=0 时 extra 还需要吗?答:需要时仍可配置实时缓冲,按背压需求定。
- 缓冲淘汰策略可配吗?答:SharedFlow 提供溢出策略参数,具体选项以版本文档为准(待确认)。
04.8.2.2-065 StateFlow 与 conflate() 后的 Flow 在更新语义上有何异同?
一句话结论
两者都倾向「只取最新值」:conflate 的冷流在下游慢时覆盖中间排队值,但每次订阅独立跑上游;StateFlow 是共享的单一当前状态,更新去重、新订阅者拿到当前值,上游一份共享。选择取决于是否需要共享状态与跨订阅快照。
概念解释
- conflate:冷流合并最新,无状态持有。
- StateFlow:热状态流,持有当前值。
- 并发语义:都避免积压旧值。
原理流程
- conflate 通道保最新,下游取快照。
- 每次 collect 重新执行上游。
- StateFlow 内部维护状态,共享给所有订阅者。
- 状态去重与初始值由 StateFlow 保证。
代码或图示
source.conflate().collect { }
val state = source.stateIn(scope, SharingStarted.Lazily, idle)
常见误区
- 以为 conflate 流自动共享一份上游:仍是冷流,多次订阅独立。
- 用 StateFlow 发高频流式更新:状态去重可能合并非等价中间帧。
追问
- 高频传感器数据流选哪个?答:需要共享最新快照用 StateFlow;单次订阅处理用 conflate 冷流。
- StateFlow 能否表达序列历史?答:不能,只保留当前值,历史需自行缓存。
04.8.2.2-066 热流上游异常后,新订阅者会收到什么?
一句话结论
上游失败终止后热流处于结束状态:已订阅者收到结束/失败信号,新订阅者不会重启上游;需要持续可用的流应在共享作用域内实现重试重建,或让状态沉淀为错误 StateFlow,订阅者按结束原因处理。
概念解释
- 热流生命周期随共享 Scope。
- 上游异常 = 流终止,不是暂停。
- 自动恢复需显式重建逻辑。
原理流程
- 上游抛异常,共享 Job 失败。
- 通道/状态流结束,携带失败原因。
- 订阅者 onCompletion/catch 感知失败。
- 重建需新的 shareIn/stateIn 或内部重试循环。
代码或图示
source.retry(3).stateIn(scope, SharingStarted.Lazily, idle)
常见误区
- 以为流失败后会自动重新订阅上游:不会,除非内部有 retry。
- 新订阅者能恢复已终止上游:不能,共享实例已结束。
追问
- 重试放在 stateIn 之前还是之后?答:放在上游 Flow 链上 retry,再 stateIn 共享。
- 失败状态如何让 UI 展示?答:catch 映射错误状态写入 StateFlow。
04.8.2.2-067 如何把回调/轮询数据源封装成可复用的冷 Flow?
一句话结论
用 callbackFlow 注册回调并 trySend、awaitClose 反注册;轮询源用 flow{} 内 while(isActive) { emit(...); delay(period) };封装为返回 Flow 的函数,每次 collect 独立建立数据源,取消时自动反注册或停止轮询。
概念解释
- 回调源:callbackFlow + awaitClose。
- 定时轮询:无限流 + delay + 取消检查。
- 封装边界:订阅时建立,取消时释放。
原理流程
- 函数返回 Flow,不提前启动数据源。
- collect 时注册回调或进入轮询循环。
- 元素经通道/emit 交下游。
- 取消触发反注册或退出循环。
代码或图示
fun pollingFlow(): Flow<Long> = flow {
while (currentCoroutineContext().isActive) {
emit(System.currentTimeMillis())
delay(1000)
}
}
常见误区
- 数据源在类初始化时就启动:破坏冷流按需订阅语义。
- 轮询循环不检查取消:页面销毁后仍跑定时器。
追问
- 多个订阅者各起一个轮询是否浪费?答:是,需要共享则用 shareIn 转为热流。
- 回调多次快速到达会积压吗?答:按通道缓冲/溢出策略处理。
04.8.2.2-068 Flow 链上的副作用应该放在哪一层?
一句话结论
纯数据变换放中间操作符(map/transform),副作用(日志、埋点、写缓存)尽量收敛到末端 collect 或明确的 onEach;中间操作符可能被重试、多次订阅或缓冲执行,副作用位置不当会重复触发或时序错乱。
概念解释
- 冷流多次订阅,链上副作用会重复。
- 重试会重跑上游前置副作用。
- 末端收集是唯一确定的消费落点。
原理流程
- 区分变换与副作用。
- 变换保持纯函数。
- 副作用集中在 collect 或受控 onEach。
- 重试/多次订阅时副作用次数可预期。
代码或图示
source
.map { transform(it) }
.collect { persist(it) } // 副作用在此
常见误区
- 在 map 里发网络请求/写库:被重试或重复订阅时重复执行。
- onEach 副作用假设只执行一次:冷流每次订阅都会跑前置链。
追问
- 必须在中间层记日志怎么办?答:用 onEach 并注明副作用语义,确认订阅与重试次数。
- 共享热流上的副作用执行几次?答:上游一份,中间层随共享上游执行一次,下游各订阅独立。
04.8.2.2-069 无限 Flow 在页面销毁时如何保证停止?
一句话结论
无限流(轮询、监听、传感器)必须在绑定页面/组件生命周期的作用域内 collect;作用域取消时取消信号沿链到达上游,轮询 delay 挂起点响应取消,回调源经 awaitClose 反注册;不要用脱离生命周期的全局作用域收集。
概念解释
- 取消传播从收集协程到上游。
- 轮询在 delay 点可被取消。
- 回调源清理依赖 awaitClose。
原理流程
- 在 lifecycleScope/viewModelScope 内 collect。
- 组件销毁取消作用域。
- 取消信号到达无限流上游。
- delay/挂起点退出,awaitClose 释放订阅。
代码或图示
lifecycleScope.launch {
sensorFlow.collect { render(it) }
}
常见误区
- GlobalScope 收集无限流:页面销毁后继续跑并持有引用。
- 回调源不写 awaitClose:取消后监听器不释放。
追问
- 轮询在单次执行中途被取消怎么办?答:在任务内检查 isActive,finally 释放资源。
- 后台需要持续监听怎么办?答:放到应用级作用域并独立管理生命周期,不依附页面。
04.8.2.2-070 设计一个「搜索输入 → 取消旧请求 → 展示结果」的 Flow 链,关键操作符是什么?
一句话结论
输入事件源用 Flow 采集文本变化,debounce 过滤连续输入,flatMapLatest 为每个查询发起搜索并在新输入到来时取消旧请求,结果经 catch 兜底后回 UI 状态;关键是 latest 切换、防抖与取消旧异步任务。
概念解释
- debounce:合并停顿前的连续输入。
- flatMapLatest:新查询取消旧子流。
- 异常兜底与状态沉淀分离。
原理流程
- 输入文本作为上游 Flow。
- debounce 等待输入稳定。
- flatMapLatest 调搜索接口,旧请求被取消。
- 结果/错误写入 StateFlow,UI 订阅渲染。
代码或图示
queryFlow
.debounce(300)
.distinctUntilChanged()
.flatMapLatest { q -> searchApi(q).catch { emit(emptyResult()) } }
.stateIn(viewModelScope, SharingStarted.Lazily, empty)
常见误区
- 用 flatMapConcat:旧查询排队,新结果滞后。
- 旧请求不可取消:旧响应可能覆盖新结果,需按请求序号校验。
追问
- 接口不支持取消怎么办?答:在 flatMapLatest 内用请求编号校验,丢弃过期响应。
- 防抖时间如何定?答:按输入节奏与接口成本权衡,测试不同阈值体验。
04.8.2.2-071 debounce 与 sample 在节流语义上有何不同?
一句话结论
debounce 等待静默间隔后才发射最后一个值,用于过滤连续重复输入(如搜索框);sample 按固定时间周期取周期内最新值,用于定期采样高频流(如传感器);前者关心停顿,后者关心周期快照。
概念解释
- debounce:新值到来重置计时,停顿到期发射。
- sample:周期性发射窗口内最新值。
- 两者都是时间相关的中间操作符。
原理流程
- debounce 收到值后重启静默定时器。
- 间隔内无新值,发射最后值。
- sample 每到周期边界发射最近一次值。
- 无限流取消时定时器随作用域终止。
代码或图示
query.debounce(300).collect { }
sensor.sample(1000).collect { }
常见误区
- 高频采样用 debounce:结果只在停顿后出现,周期数据丢失。
- 连续输入用 sample:每个周期都可能发中间输入,未过滤抖动。
追问
- 两个操作符在空流上行为?答:无值则不发射,流正常结束。
- 时间基于什么时钟?答:协程调度虚拟时间在测试中可控,真实时间由调度器定时器驱动。
04.8.2.2-072 onStart 与 onCompletion 如何配合流首尾?
一句话结论
onStart 在流开始收集前执行动作(如发射初始值、打开始日志),onCompletion 在流结束(正常/异常/取消)时回调;两者分别包裹流的首尾,配合 catch 可构成完整的开始、结束、异常处理骨架。
概念解释
- onStart:上游启动前的副作用或前置值。
- onCompletion:结束原因观察,不兜底发射。
- 顺序:onStart → 元素流 → onCompletion。
原理流程
- collect 启动,先执行 onStart 块。
- 上游元素向下游流动。
- 结束时 onCompletion 拿到 cause。
- 异常路径 cause 非 null,可在 catch 兜底。
代码或图示
source
.onStart { emit(Loading) }
.onCompletion { cause -> log(cause) }
.collect { }
常见误区
- 在 onCompletion 里发射恢复值:它不是 catch,不能继续流。
- onStart 里做阻塞长任务:延迟上游首个元素发射。
追问
- onStart 能发射多个初始值吗?答:能,块内可多次 emit。
- 取消时 onCompletion 的 cause 是什么?答:CancellationException。
04.8.2.2-073 retryWhen 相比 retry 多了什么控制能力?
一句话结论
retryWhen 接收(异常、尝试次数)上下文,可在谓词里决定是否重试、计算退避延迟并执行 delay,还能识别取消异常放行;retry 只按固定次数与简单谓词重试,退避与精细条件用 retryWhen。
概念解释
- retryWhen 回调拿到异常与次数上下文。
- 可在内部回调内挂起延迟,实现指数退避。
- 不满足条件返回 false,异常向下游传播。
原理流程
- 上游失败进入 retryWhen。
- 回调判断异常类型与已试次数。
- 可 delay 退避后返回 true 重新订阅。
- 返回 false 或次数用尽,异常向下游传播。
代码或图示
source.retryWhen { cause, attempt ->
if (cause is IOException && attempt < 3) {
delay(100 * attempt)
true
} else false
}
常见误区
- 取消异常也走重试:必须判断并放行 CancellationException。
- 退避延迟在 retryWhen 外设置:延迟应在重试决策点内执行。
追问
- 重试次数从 0 还是 1 开始?答:上下文 attempt 计数规则以版本文档为准(待确认)。
- 重试会重跑 onStart/onEach 吗?答:上游重新订阅,链上前置副作用按冷流规则重跑。
04.8.2.2-074 Flow 能否把元素分批聚合(chunk)?
一句话结论
标准库没有直接同名 chunk 操作符时,可通过 window/缓冲组合或在 collect 中自行累积列表实现分批;按固定数量或时间窗口聚合元素为列表,适用于批量持久化、批量上报,注意流取消时的最后一批处理。
概念解释
- 分批:把连续元素聚合成批次列表。
- 可按数量阈值或时间窗口。
- 流结束时flush 剩余不满一批的元素。
原理流程
- 收集元素累积到缓冲区。
- 达到批次条件发射列表。
- 流结束发射剩余缓冲。
- 取消路径按 finally 决定是否丢弃尾批。
代码或图示
// 数量分批思路:累积到 N 个后整体发射
source.buffer().collect { /* 自行累积并 flush */ }
常见误区
- 尾批在流取消时被静默丢弃:关键数据需确认 flush 语义。
- 批次列表可变共享:应每批新建不可变列表。
追问
- 窗口操作符在哪个包?答:查当前 kotlinx.coroutines Flow 操作符列表,旧/新操作符名以文档为准(待确认)。
- 批量失败如何重试?答:批次作为整体重试单元,注意幂等性。
04.8.2.2-075 多个 Flow 用 merge 合并后元素顺序如何?
一句话结论
merge 把多个上游 Flow 的元素汇入一个流,结果按各上游到达通道的顺序混合发射,不保证各源之间的先后;需要严格配对用 zip,需要按最新值组合用 combine,merge 只做无顺序约束的汇聚。
概念解释
- merge:并发收集所有源,到达即发射。
- 顺序反映各源生产节奏,不是源声明顺序。
- 任一源失败按流异常规则传播。
原理流程
- 为每个上游启动收集协程。
- 元素汇入同一通道。
- 下游按通道到达顺序取数。
- 全部源结束,合并流结束。
代码或图示
merge(sourceA, sourceB, sourceC).collect { }
常见误区
- 期待 merge 按 A、B、C 轮流出元素:不保证轮询顺序。
- 用 merge 聚合两个需要配对的字段:应使用 zip。
追问
- merge 并发度受什么约束?答:各源在共享/各自调度器上运行,通道缓冲与溢出策略影响排队。
- 某一源慢会拖慢 merge 吗?答:其他源仍发射,慢源只影响自身元素到达节奏。
04.8.2.2-076 冷 Flow 多次订阅为什么上游会执行多遍?
一句话结论
冷 Flow 的收集器 lambda 在每次 collect 时被独立调用,每次订阅建立独立协程与局部状态;共享状态需要显式上提到上游或转为热流,否则两次订阅各自跑一遍网络/数据库读取,产生重复副作用。
概念解释
- 冷流类似函数:调用几次执行几次。
- 局部变量不跨订阅共享。
- 副作用重复是冷流默认语义。
原理流程
- 第一次 collect 启动上游协程 A。
- 第二次 collect 启动独立协程 B。
- 两者各自执行收集器逻辑。
- 需要单份共享上游时 shareIn/stateIn。
代码或图示
val cold = flow { println("fetch"); emit(1) }
cold.collect { } // fetch
cold.collect { } // 再 fetch
常见误区
- 以为 Flow 对象缓存了上一次结果:冷流不缓存,除非转热流。
- 在收集器里初始化单例资源:每次订阅重复初始化。
追问
- 如何让上游只跑一份?答:shareIn 共享上游,订阅者收共享值。
- 重复订阅的副作用如何避免?答:资源获取放共享层,Flow 只表达数据变换。
04.8.2.2-077 把冷流转成热流后,原冷流的副作用还会重复执行吗?
一句话结论
通过 shareIn/stateIn 共享后,上游只在共享作用域内运行一份,副作用按共享策略执行一次;各订阅者接收的是共享流分发的值,不会各自重跑上游;但订阅者本地的中间操作符(链在 shareIn 之后)仍随各订阅独立执行。
概念解释
- 共享上游:一份生产者。
- 下游操作符:各订阅者独立管道。
- 缓存决定新订阅者看到的历史。
原理流程
- shareIn 在 Scope 内订阅上游一次。
- 上游副作用只发生在共享上游。
- 值分发给活跃订阅者。
- shareIn 之后的 map/collect 在各订阅侧独立运行。
代码或图示
val shared = source.shareIn(scope, SharingStarted.Eagerly)
shared.map { render(it) }.collect { } // map 在订阅侧
常见误区
- 以为转热流后所有操作符都只跑一份:只有 shareIn 之前的上游共享。
- 共享上游不随 Scope 取消:生命周期泄漏。
追问
- 共享上游何时启动?答:按 SharingStarted 策略(Eagerly/Lazily/WhileSubscribed)。
- 多个订阅者同时连接,值会重复广播吗?答:每个活跃订阅者各收一份,元素不互相竞争。
04.8.2.2-078 Flow 在不同调度器间切换时,元素传递经过什么?
一句话结论
跨调度器边界(flowOn、buffer)通过通道传递元素:上游在自己调度器 send,下游在自己调度器 receive;元素对象本身不变,但执行线程在边界两侧不同,阻塞任务应放在独立上游调度边界,避免卡住下游。
概念解释
- 通道是跨线程交接的桥梁。
- 元素序列化/拷贝不是默认行为,直接传引用。
- 可变对象跨线程共享需自行保证不可变或同步。
原理流程
- flowOn 在上游段替换调度器。
- 段末元素进入边界通道。
- 下游调度器从通道取数恢复续体。
- 线程切换发生在通道交接点。
代码或图示
source.flowOn(Dispatchers.IO).collect { /* 收集上下文线程 */ }
常见误区
- 跨调度器传递可变集合引用:两侧可能并发修改。
- 假设元素处理线程连续不变:边界两侧线程可能不同。
追问
- 通道传大对象有拷贝开销吗?答:默认传引用,无深拷贝;对象本身的构造与复制成本另算。
- 如何确认某操作符跑在哪个线程?答:日志记录线程名与上下文 Dispatcher。
04.8.2.2-079 UI 层收集 Flow 时如何避免主线程积压?
一句话结论
UI 收集协程绑定生命周期,结果更新只做轻量渲染;重计算与阻塞放上游/IO 边界,流用 conflate 或 collectLatest 抑制中间积压;批量数据先在后台分页/裁剪,主线程不做重解析,避免消息循环被长任务卡住。
概念解释
- 主线程只做视图更新,不做阻塞 IO/重计算。
- 背压策略防止旧帧积压。
- 数据量控制减少单帧渲染成本。
原理流程
- 上游在后台调度器加载/解析数据。
- 流经缓冲/合并策略控制投递节奏。
- 主线程 collect 只更新状态与视图。
- 页面销毁作用域自动取消收集。
代码或图示
lifecycleScope.launch {
uiState.collect { state -> render(state) }
}
常见误区
- 在 collect 里解析大 JSON/排序列表:占主线程造成掉帧。
- 高频流不加合并策略:旧帧排队,界面滞后于最新状态。
追问
- 列表大列表如何分页渲染?答:上游分页产出,StateFlow 持有页面快照,UI 增量绑定。
- collectLatest 在主线程取消旧渲染安全吗?答:渲染块应无副作用残留,复杂布局构建放后台。
04.8.2.2-080 Flow 测试中如何验证发射序列与异常?
一句话结论
用 runTest 的 TestScope 收集 Flow 到列表,断言元素顺序与数量;异常用 runCatching/catch 捕获后断言类型;时间相关操作符用虚拟时间 advanceTimeBy 推进,避免真实 sleep;取消场景验证上游是否随收集协程取消。
概念解释
- 测试调度器控制执行与虚拟时间。
- 收集结果可断言完整序列。
- 异常与结束原因可分别验证。
原理流程
- runTest 内启动收集协程。
- 元素收集到 mutableList。
- 推进虚拟时间触发定时操作符。
- 断言序列、异常类型与取消行为。
代码或图示
@Test
fun `emits sequence`() = runTest {
val values = mutableListOf<Int>()
source.collect { values.add(it) }
assertEquals(listOf(1, 2), values)
}
常见误区
- 用 Thread.sleep 等 debounce/delay:慢且不稳定。
- 只断言最终值不验证中间序列:漏掉重复/乱序问题。
追问
- 测试无限流怎么停?答:take 限长或手动 cancel 收集 Job。
- 如何验证上游被取消?答:在收集 Job cancel 后检查上游资源释放回调。
04.8.2.2-081 收集 Flow 的协程被取消时,已经发射到通道缓冲的元素怎么办?
一句话结论
收集协程取消后通道随作用域终止,缓冲中未消费元素按取消语义丢弃(不保证继续交付);关键数据不能依赖缓冲兜底,应在流外部持久化;取消后下游不会再处理残留元素。
概念解释
- 取消是终止信号,不是优雅排空。
- 缓冲元素属于内存临时队列。
- 不可丢事件需落盘或可靠队列。
原理流程
- 收集协程 cancel。
- 边界通道关闭,等待者收到取消。
- 残留元素不再被消费。
- 上游在挂起点/检查点停止。
代码或图示
val job = scope.launch { source.collect { } }
job.cancel() // 缓冲未消费元素丢弃
常见误区
- 以为取消前缓冲元素一定会被处理完:取消路径不保证排空。
- 用内存通道承担持久化队列职责:进程退出即丢失。
追问
- 想优雅排空怎么做?答:取消前显式等待当前批次完成,配合独立收尾作用域。
- 通道关闭残留元素可读取吗?答:关闭后已入队元素可被 receive 取完,取消路径则按终止处理。
04.8.2.2-082 Flow.collect 与 Flow.launchIn 的区别是什么?
一句话结论
collect 是末端挂起收集,在当前协程内处理元素;launchIn(scope) 在指定作用域启动一个新协程执行收集并返回 Job,适合把收集挂到页面/组件作用域,无需手写 launch 包裹 collect。
概念解释
- collect:挂起调用点顺序收集。
- launchIn:启动独立收集协程,返回 Job。
- 两者都触发冷流订阅。
原理流程
- collect 在当前协程沿链处理元素。
- launchIn 在 scope 内 launch 收集块。
- 收集 Job 挂到 scope 父子链。
- scope 取消时收集协程一并取消。
代码或图示
source.onEach { }.launchIn(viewModelScope)
常见误区
- 以为 launchIn 返回热流:它只启动收集,Flow 仍是冷流。
- launchIn 到脱离生命周期的 Scope:收集泄漏。
追问
- launchIn 与 scope.launch{ collect{} } 等价吗?答:语义等价,launchIn 是便捷封装。
- 收集异常如何处理?答:在链上 catch,或靠作用域 Handler 兜底。
04.8.2.2-083 为什么 Flow 收集器里不能随便 launch 子协程并发发射?
一句话结论
flow {} 收集器契约要求串行 emit,并发从多个协程调用 emit 违反约束,顺序与状态不可预测;需要并发多源发射应使用 channelFlow,其内部通道支持并发 send,并由统一作用域管理子协程取消。
概念解释
- flow{} 单收集器顺序模型。
- channelFlow 通道支持并发生产者。
- 违反串行契约可能产生不可靠行为。
原理流程
- flow{} 内 launch 子协程并发 emit。
- 多个续体竞争同一收集器,顺序无保证。
- channelFlow 内子协程 send 到线程安全通道。
- 通道串行交下游,取消随作用域传播。
代码或图示
channelFlow {
launch { send(a()) }
launch { send(b()) }
}
常见误区
- 以为 launch 出去的子协程异常会自动回到流:channelFlow 作用域内按协程异常规则处理。
- 在 flow{} 里用线程池回调 emit:同样违反串行约束。
追问
- channelFlow 子协程失败如何影响流?答:按作用域 Job 策略传播,异常可在下游 catch 感知。
- 并发 send 需要互斥吗?答:通道内部保证线程安全,生产者无需另加锁。
04.8.2.2-084 StateFlow 的 value 在并发读时是否安全?
一句话结论
StateFlow 内部以线程安全方式持有状态值,读取 value 可在不同协程/线程间进行;但读改写(先读 value 再计算写回)不是原子复合操作,并发更新要用 update/compareAndSet,避免丢失更新。
概念解释
- 单个 value 读:安全可见。
- 复合读改写:需要原子更新原语。
- 状态对象本身应不可变,避免内部被并发修改。
原理流程
- 任意线程读取当前 value。
- 并发更新经 CAS 尝试写入。
- 冲突时 update 重试基于最新值重算。
- 新值 equals 相同则不广播。
代码或图示
state.update { it.copy(count = it.count + 1) }
常见误区
- 并发
state.value = state.value.copy(...):读改写交错丢失自增。 - 状态对象内部可变集合被共享修改:equals 与可见性都不可靠。
追问
- 多线程订阅 StateFlow 安全吗?答:订阅回调按状态流分发机制执行,具体线程取决于上游上下文。
- 状态快照如何保证不被后续修改?答:使用不可变 data class 与只读集合。
04.8.2.2-085 SharedFlow 的 trySend 满员时元素会怎样?
一句话结论
trySend 非阻塞投递,缓冲满时按 SharedFlow 溢出策略处理:挂起策略下返回已满结果(不丢弃但未入队),丢弃策略丢弃最旧或最新;结果对象需检查,不能假设元素一定被接收。
概念解释
- trySend 立即返回 ChannelResult/SharedFlow 投递结果。
- 策略决定满时去留。
- 回调线程不能挂起等待,故用 trySend。
原理流程
- trySend 检查缓冲槽位。
- 有槽位入队并广播给订阅者。
- 满员按溢出策略处理或返回满结果。
- 调用方根据结果决定降级或日志。
代码或图示
val result = flow.trySend(event)
if (result.isSuccess) { /* 已入队 */ }
常见误区
- 忽略 trySend 结果:满员丢值无感知。
- 在回调线程用 send 挂起:可能阻塞回调线程。
追问
- SharedFlow 投递结果类型?答:以当前版本 API 为准,可查 KDoc 的 send/trySend 返回类型(待确认)。
- 满员事件需要补偿吗?答:关键事件应改有界 SUSPEND 或持久化队列。
04.8.2.2-086 一个 Flow 链里既有阻塞旧库调用又有 UI 更新,调度边界应如何划?
一句话结论
阻塞旧库调用放在上游并用 flowOn(Dispatchers.IO) 隔离;UI 更新只在收集上下文(Main)执行;不要在 flow{} 收集器内自行切线程,阻塞任务不得进入 Main 段,跨边界元素传不可变结果。
概念解释
- 调度边界由 flowOn 明确表达。
- 阻塞与非阻塞段分离。
- 边界两侧线程不同,状态传递用值对象。
原理流程
- 上游调用阻塞旧库,flowOn(IO) 包裹。
- 结果变换为不可变 DTO。
- 边界通道交到 Main 收集上下文。
- collect 内只更新视图状态。
代码或图示
flow { emit(blockingQuery()) }
.flowOn(Dispatchers.IO)
.collect { render(it) }
常见误区
- 在 Main 段调用同步 JDBC/文件读:阻塞消息循环。
- 跨线程传递可变列表引用:两侧并发修改风险。
追问
- 非阻塞异步客户端需要 flowOn(IO) 吗?答:不需要靠阻塞线程等待,按其自有调度接入。
- 阻塞调用失败如何退出流?答:抛异常经 catch 映射错误状态。
04.8.2.2-087 Flow 与回调式接口互操作时,如何避免「回调晚于取消到达」?
一句话结论
桥接层在回调内检查通道/流是否已关闭,已取消则丢弃结果并清理;awaitClose 反注册订阅;对不能反注册的 API 用弱引用与关闭标记,避免回调操作已销毁的页面或重复投递过期结果。
概念解释
- 取消与回调到达存在竞态。
- 关闭标记是回调侧的防护判断。
- 资源反注册在 awaitClose 完成。
原理流程
- 订阅回调注册到外部 API。
- 流取消,awaitClose 反注册。
- 迟到回调到达,检查关闭状态丢弃值。
- 弱引用避免长生命周期持有页面对象。
代码或图示
callbackFlow {
val listener = onResult { r ->
if (!isClosedForSend) trySend(r)
}
api.register(listener)
awaitClose { api.unregister(listener) }
}
常见误区
- 取消后回调直接更新 View:引用泄漏与崩溃。
- 反注册后仍保留强引用到上下文:旧对象无法回收。
追问
- 回调结果带请求序号如何防过期?答:flatMapLatest 或序号校验,丢弃过期响应。
- 竞态窗口内反注册未完成怎么办?答:标记关闭状态,回调双重检查后丢弃。
04.8.2.2-088 如何在 Flow 链中保留元素的处理上下文(如 traceId)?
一句话结论
上下文随协程上下文元素或元素字段显式传递:业务标识作为数据字段携带在元素里;需要协程级上下文可用自定义 CoroutineContextElement 在作用域合并后沿链继承;Flow 操作符不自动跨线程复制任意线程局部变量。
概念解释
- 线程局部变量不随协程续体自动传播。
- 数据字段是最可靠的跨边界传递方式。
- 自定义上下文元素随协程上下文继承。
原理流程
- traceId 放入元素 DTO 或上下文元素。
- 上游生成后沿流传递。
- 跨调度器边界随元素引用传递。
- 下游日志读取标识关联链路。
代码或图示
data class Item(val traceId: String, val value: Int)
常见误区
- 依赖 ThreadLocal 跨线程传递:协程切换线程后丢失。
- 在操作符里从线程局部取标识:边界另一侧取不到。
追问
- 上下文元素能在 Flow 上游自动继承吗?答:随收集协程上下文继承,flowOn 只替换调度元素,其余元素保留。
- 跨进程/服务透传怎么做?答:元素字段携带标识,随请求头传递。
04.8.2.2-089 热流在配置变更后是否会丢失已有状态?
一句话结论
绑定 ViewModel 作用域的 StateFlow/SharedFlow 在配置变更后仍存活,状态保留;绑定 Lifecycle 作用域的收集随视图销毁断开,重建后重新订阅 StateFlow 可拿到当前快照;SharedFlow(replay=0) 的一次性事件在断开期间会丢失,需按需配置 replay 或改用持久化状态。
概念解释
- 配置变更不销毁 ViewModel。
- 视图作用域收集断开不等于上游销毁。
- 事件流不缓存断开期间的事件。
原理流程
- 旋转重建视图,ViewModel 与其中热流存活。
- 新视图订阅 StateFlow 拿到当前状态。
- replay=0 事件不补发断开期间事件。
- 进程回收时 ViewModel 与状态才清除。
代码或图示
// ViewModel 持有状态,配置变更后保留
val state: StateFlow<UiState> = _state.asStateFlow()
常见误区
- 用 replay=0 SharedFlow 存界面状态:重建后拿不到快照。
- 以为视图断开会销毁共享上游:ViewModel 作用域内继续存活。
追问
- 断开期间的事件需要补发吗?答:需要则提高 replay 或沉淀为 StateFlow;一次性瞬时事件不补发。
- 进程重建后状态如何恢复?答:从持久化层重新加载初始状态。
04.8.2.2-090 选择 Flow、Channel、SharedFlow、StateFlow 的决策要点是什么?
一句话结论
管道变换与单次订阅选冷 Flow;协程间任务交接、多路等待、精确容量原语选 Channel;多订阅广播事件选 SharedFlow;单一可观察界面状态选 StateFlow;按「订阅次数、是否共享、有无当前快照、能否丢值」四个维度判定。
概念解释
- 冷 Flow:按需订阅,变换管道。
- Channel:底层通信队列,单次消费。
- SharedFlow:热广播,可配重放。
- StateFlow:热单值状态,自动去重。
原理流程
- 是否需要共享上游:是 → 热流。
- 是否只有单一状态快照:是 → StateFlow。
- 广播事件与缓存策略:SharedFlow。
- 底层任务交接与 select:Channel。
代码或图示
// 管道:Flow;事件广播:SharedFlow;状态:StateFlow;任务队列:Channel
常见误区
- 所有数据通信都用 Channel:缺少操作符与订阅管理。
- 所有状态都用 StateFlow:一次性事件被重复消费。
追问
- 组合使用可行吗?答:可行,如 channelFlow 内部用通道,对外暴露 Flow;状态与事件分层持有。
- 迁移旧 Channel 代码到 Flow 的步骤?答:先识别消费语义,再映射到 Flow/SharedFlow 对应模型。
04.8.2.2-091 高频定位更新的场景,流策略应如何搭配?
一句话结论
定位/传感器等高频更新用 sample 周期取快照或 conflate 保最新,避免中间值积压;展示层用 collectLatest 在新位置到达时取消旧的渲染/请求;关键轨迹点再批量持久化,不可丢的上报走独立有界队列或持久化通道。
概念解释
- 高频源需要节奏控制。
- 旧渲染任务可被新值取消。
- 持久化与展示分流,互不阻塞。
原理流程
- 定位回调经 callbackFlow 进入流。
- sample/conflate 控制投递节奏。
- collectLatest 刷新界面,旧任务取消。
- 关键点写入独立持久化队列异步上报。
代码或图示
locationFlow
.sample(500)
.collectLatest { render(it) }
常见误区
- 每个原始定位点都触发网络请求:请求风暴与旧响应覆盖。
- 上报队列无界:内存积压,关键轨迹反而丢失。
追问
- 旧定位请求如何防覆盖?答:请求序号校验,过期响应丢弃。
- 后台持续定位用什么作用域?答:应用级/服务级 Scope,不依附页面生命周期。
04.8.2.2-092 流中某个元素处理失败,如何不中断整条流?
一句话结论
在元素处理层把失败包装为结果类型(runCatching/密封结果),让失败作为值继续流动;或用 catch 只兜底上游特定异常并 emit 降级值;不要让单元素异常冒泡终止整条流,除非业务要求整体失败。
概念解释
- 元素级容错:失败不中断序列。
- 流级 catch:兜底上游异常转为结束/降级。
- 结果类型让下游显式处理成功失败。
原理流程
- 每元素处理包 runCatching。
- 结果作为值发射到下游。
- 下游分别处理成功与失败项。
- 上游源异常用 catch 整体兜底。
代码或图示
source.map { runCatching { process(it) } }
.collect { result -> result.onSuccess { }.onFailure { } }
常见误区
- 一条记录失败就中断整个批次流:可恢复场景应隔离失败。
- catch 把所有异常吞成空值:丢失错误上报与可观测性。
追问
- 失败元素需要重试怎么办?答:元素级重试在 map 内处理,避免整条流重放。
- 错误状态如何反映到 UI?答:失败结果写入状态快照或事件流。
04.8.2.2-093 上游缓慢时 StateFlow 是否会积累未处理状态?
一句话结论
StateFlow 只保留当前最新状态,新状态覆盖旧状态,不积压未消费的中间帧;订阅者处理慢时拿到的是最新快照,这与有界缓冲队列不同;代价是中间状态可能被跳过,需要完整历史序列时应使用 SharedFlow/通道。
概念解释
- StateFlow 单值覆盖模型。
- 无中间队列积压。
- 跳过中间值是设计取舍。
原理流程
- 新状态写入覆盖当前 value。
- 订阅者收到最新值通知。
- 未消费的旧中间值被覆盖。
- 需要历史时另建缓存或序列流。
代码或图示
state.update { it.copy(progress = next) } // 旧进度被覆盖
常见误区
- 用 StateFlow 记录完整操作历史:只留当前快照。
- 期待每个状态变更都被独立处理:状态流去重且覆盖。
追问
- 进度条中间帧需要展示吗?答:需要连续动画则用 SharedFlow/通道,StateFlow 只适合最终进度。
- 订阅者慢导致通知合并吗?答:状态流以最新值为准,具体合并行为以实现文档为准(待确认)。
04.8.2.2-094 Flow 取消时 awaitClose 与 finally 分别适合清理什么?
一句话结论
finally/use 清理当前协程作用域内获取的资源(连接、订阅句柄);awaitClose 是 callbackFlow/channelFlow 专用的反注册回调,在通道关闭时解除外部 API 订阅;两者配合:协程内资源走 finally,外部回调注册走 awaitClose。
概念解释
- finally:协程退出栈展开时执行。
- awaitClose:通道关闭事件驱动的清理。
- 职责不同,不要互相替代。
原理流程
- 协程内资源在 try 块获取,finally 释放。
- 外部回调注册在 channelFlow 块内。
- 流关闭触发 awaitClose 反注册。
- 取消路径两条清理都执行。
代码或图示
callbackFlow {
val subscription = api.observe(::trySend)
try {
// 流内逻辑
} finally {
localResource.close()
}
awaitClose { subscription.cancel() }
}
常见误区
- 把外部反注册写进 finally:callbackFlow 块结束时机与通道关闭不完全等同。
- 只写 awaitClose 不释放协程内本地资源:本地资源走 finally。
追问
- awaitClose 能注册多个清理动作吗?答:可在回调内组合多个释放步骤。
- 清理顺序如何保证?答:按资源依赖顺序编排,必要时 NonCancellable 包裹挂起释放。
04.8.2.2-095 多模块共享一个事件流时,作用域与重复订阅如何设计?
一句话结论
事件流在应用级或仓库级作用域内 shareIn 形成单份共享上游;各模块在自己生命周期作用域内 collect,断开只取消局部订阅;replay 按是否需要补发历史事件配置,避免模块销毁后共享上游仍被局部作用域持有。
概念解释
- 上游共享:一份生产者。
- 订阅局部:各模块独立断开。
- 生命周期分层:应用 Scope 保上游,页面 Scope 管订阅。
原理流程
- 仓库内构建 MutableSharedFlow 或 shareIn。
- 模块在自身 Scope 收集事件。
- 模块销毁取消局部收集,不影响共享上游。
- 应用退出取消共享上游。
代码或图示
val shared = source.shareIn(appScope, SharingStarted.Eagerly, replay = 0)
常见误区
- 每个模块各自 shareIn 一份上游:重复生产与副作用。
- 局部收集时传 GlobalScope:模块销毁订阅不断开。
追问
- 事件会不会被某个模块消费后消失?答:SharedFlow 广播,各模块独立收全量;Channel 才是竞争消费。
- 跨模块事件需要类型隔离吗?答:按事件密封类型分层,避免无关模块收到敏感事件。
04.8.2.2-096 为什么不建议在 Flow 收集器内直接抛 CancellationException 之外的业务异常后静默?
一句话结论
Flow 异常沿链传播到收集协程作用域,静默吞掉会破坏错误可观测性与结构化并发;业务失败应转为结果值或经 catch 映射为错误状态,取消异常必须放行,未处理异常应上报到统一兜底处理器。
概念解释
- 异常是错误信号,需要被记录或展示。
- 取消异常不能当业务错误吞掉。
- 结果类型与 catch 是合法的显式容错。
原理流程
- 任务内区分取消、业务失败、系统异常。
- 可预期失败封装为结果值。
- 系统异常经 catch 记录并映射状态。
- 未捕获异常冒泡到作用域 Handler 上报。
代码或图示
source.catch { e ->
if (e is CancellationException) throw e
emit(ErrorState(e))
}
常见误区
- catch(Exception) 后空体返回:故障无日志、无降级。
- 吞掉取消异常继续发值:破坏取消传播。
追问
- 错误上报放在哪一层?答:上游兜底 Handler 或 catch 内统一日志/监控。
- 业务错误码如何进流?答:密封结果类型携带错误枚举,不依赖异常控制流。
04.8.2.2-097 虚拟时间下如何测试 debounce/flatMapLatest 的切换行为?
一句话结论
在 runTest 中用测试调度器发射元素,advanceTimeBy 推进防抖窗口,断言只收到稳定后的结果;flatMapLatest 场景推进时间后确认旧子流被取消、新结果生效;不依赖真实时钟与 sleep。
概念解释
- 测试调度器虚拟时钟驱动时间操作符。
- 手动推进时间触发到期回调。
- 可断言取消旧任务的清理回调。
原理流程
- 测试内构造上游源与被测链。
- 发射连续输入。
- advanceTimeBy 越过 debounce 窗口。
- 断言输出序列与旧子流取消行为。
代码或图示
@Test
fun `debounce emits after quiet period`() = runTest {
source.emit("a"); source.emit("ab")
advanceTimeBy(301)
assertEquals("ab", observed.last())
}
常见误区
- 不推进时间就断言 debounce 结果:定时器未到期。
- 用真实 sleep 等待 latest 切换:测试慢且偶发失败。
追问
- 如何断言旧请求被取消?答:在旧子任务注册取消回调,验证回调触发。
- 虚拟时间能加速真实网络吗?答:不能,测试中需 mock 异步源。
04.8.2.2-098 Flow 元素携带可变状态时,跨操作符需要注意什么?
一句话结论
跨操作符与调度边界优先传递不可变值;若元素含可变集合,不得在多个协程/操作符间并发修改;需要更新状态时复制为新对象放入新元素,保证每个阶段看到的快照一致,避免引用共享导致的并发修改与脏读。
概念解释
- 跨线程传递可变引用是隐患。
- 不可变 data class + 只读集合更安全。
- 状态更新走复制新对象。
原理流程
- 上游产出不可变元素。
- 变换阶段复制生成新元素。
- 跨边界传递引用但不修改内部。
- 下游读取快照渲染。
代码或图示
data class Snapshot(val items: List<Item>) // 只读 List
常见误区
- 在 map 里原地改上游传入的集合:下游与其他订阅者读到被改状态。
- 把 ArrayList 直接放进 StateFlow:并发修改与 equals 风险。
追问
- 必须共享可变对象怎么办?答:封闭到单线程调度器访问,或用同步原语保护,不跨边界裸传。
- 深拷贝成本高如何权衡?答:按并发边界判断,跨调度器/订阅共享时复制局部必要状态。
04.8.2.2-099 版本演进中 Flow/Channel API 有哪些需要核对的待确认点?
一句话结论
不同 kotlinx.coroutines 版本在 Channel 容量默认值、SharedFlow 溢出策略选项、部分通道接收扩展的废弃标注、SharingStarted 策略细节上存在演进;落地前应以项目实际依赖版本的 KDoc 与 changelog 为准,不确定处标注「待确认」并写明验证点,不凭记忆断言版本行为。
概念解释
- 废弃 API 与替代按版本迁移。
- 默认容量/策略常量可能调整。
- 测试库 API 也随版本演进。
原理流程
- 确认项目 kotlinx.coroutines 版本号。
- 对照官方文档与 KDoc 核对常量与签名。
- 运行测试验证行为假设。
- 文档中标注待确认点与验证方法。
代码或图示
待确认项示例:BUFFERED 默认容量、SharedFlow 溢出策略枚举、consumeEach 废弃状态、WhileSubscribed 超时参数
常见误区
- 照搬旧博客的常量名/默认值:版本不同行为可能不同。
- 不查版本就断定某扩展已移除:可能仍保留为 deprecated。
追问
- 去哪里查版本行为?答:kotlinx.coroutines GitHub releases/changelog 与对应 API KDoc。
- 升级大版本测试重点?答:背压策略、取消传播、废弃 API 替换与测试调度器行为。
04.8.2.2-100 设计一个「多源数据合并 → 状态沉淀 → 事件通知」的 Flow 架构,要点有哪些?
一句话结论
多个上游分别封装为冷 Flow,combine 合并为界面状态写入 StateFlow;一次性提示/导航用 replay=0 的 SharedFlow;上游在仓库级作用域共享,UI 在页面作用域收集;错误映射为错误状态,取消随页面销毁传播,关键事件与状态分层不混用。
概念解释
- 状态流:可恢复的界面快照。
- 事件流:一次性通知。
- 多源合并基于最新值组合。
原理流程
- 各数据源封装为冷 Flow 并处理取消与反注册。
- combine 聚合最新值生成 UiState。
- stateIn 沉淀状态,SharedFlow 发一次性事件。
- UI 收集状态渲染、收集事件执行单次动作;页面销毁取消局部收集。
代码或图示
val state = combine(userFlow, orderFlow) { u, o ->
UiState.Ready(u, o)
}.stateIn(appScope, SharingStarted.WhileSubscribed(), UiState.Loading)
private val _events = MutableSharedFlow<UiEvent>(replay = 0)
val events: SharedFlow<UiEvent> = _events
常见误区
- 把导航/Toast 写进 StateFlow:重复订阅导致重复执行。
- 多源用 zip 聚合状态:频率不同互相等待,应用 combine。
- 上游在页面作用域共享:页面销毁后状态流重建丢失缓存。
追问
- 某一源失败如何不拖垮整体?答:源内 catch 映射为失败快照,combine 继续用其他最新值。
- 跨模块订阅生命周期如何对齐?答:上游挂应用/仓库 Scope,订阅挂页面 Scope,分层取消。
参考来源
- Kotlin Flow 官方指南:冷流、操作符、缓冲、背压与异常处理机制。
- kotlinx.coroutines Channel 文档:通道容量、溢出策略、关闭与收发原语。
- SharedFlow/StateFlow API 文档:热流、重放缓存、订阅计数与状态模型。
- callbackFlow/channelFlow 文档:并发发送、awaitClose 与回调桥接。
- kotlinx.coroutines GitHub 仓库:版本 changelog、废弃 API 与迁移说明。
待整理清单
- [ ] 核对当前依赖版本下 BUFFERED 默认通道容量的具体数值。
- [ ] 核对 SharedFlow 溢出策略枚举与 replay/extraBufferCapacity 组合行为。
- [ ] 核对
consumeEach、旧 actor 扩展在当前版本的废弃标注与替代 API。 - [ ] 核对
SharingStarted各策略(Eagerly/Lazily/WhileSubscribed)参数与默认超时。 - [ ] 整理 Flow 操作符在当前版本的完整分类清单与废弃替代对照。