罗罗编程学习记录
本页内容 展开查看

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 类型只描述数据流,不含运行中的生产者。

原理流程

  1. 构造 Flow 时只保存收集器 lambda,不执行。
  2. 调用 collect 时启动协程运行上游。
  3. 上游 emit 把值交给下游处理。
  4. 再次 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 逐级包装后的调用链。
  • 插入缓冲操作符后上下游才解耦为独立协程。

原理流程

  1. collect 启动收集协程,沿操作符链向下调用。
  2. 上游 emit(x) 调下游处理函数。
  3. 下游处理完返回,emit 才继续下一个值。
  4. 下游慢时上游被挂起在 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 进入数据流管道。

原理流程

  1. 判定数据来源:动态异步用 flow{}。
  2. 常量列表用 flowOf。
  3. 已有集合/序列用 asFlow 适配。
  4. 三者产出的都是冷 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 感知。

原理流程

  1. collect 启动协程,上游收集器开始执行。
  2. 值逐个向下游流动。
  3. 上游 emit 完毕,Flow 正常结束。
  4. 收集协程取消 → 取消信号沿操作符链到达上游挂起点。

代码或图示

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,结构最灵活。

原理流程

  1. 上游值进入操作符链。
  2. map 变换后向下游 emit 一个结果。
  3. filter 谓词不通过则不向下游发送。
  4. 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 返回变换后的新类型。
  • 两者都是顺序处理元素的中间操作符。

原理流程

  1. 元素到达 onEach,执行副作用 lambda。
  2. 原值继续向下游。
  3. map 把 lambda 返回值作为新元素发出。
  4. 副作用失败同样中断流并传播异常。

代码或图示

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:响应最新值,丢弃旧任务结果。

原理流程

  1. 上游每个元素映射为一个子 Flow。
  2. Concat 串行收集子流,合并发射。
  3. Merge 并发启动多个子流,结果到达即发射。
  4. 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。

原理流程

  1. zip 维护各流队列,成对取出组合。
  2. 一流速另一流慢时快者排队等待。
  3. combine 订阅所有源,任一更新触发组合 lambda。
  4. 组合输出基于当前各源最新值。

代码或图示

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 之后的链路。

原理流程

  1. 收集协程沿链向下执行。
  2. 上游某节点抛异常,向上回溯经过 catch。
  3. catch lambda 处理异常,可 emit 兜底值。
  4. 异常若在 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 是冷操作符:重试 = 重新跑一遍上游收集器。
  • 可配次数、谓词与超时退避。
  • 重试会重复上游副作用,需保证幂等。

原理流程

  1. 上游发射中抛异常,回溯到 retry。
  2. 谓词判断是否可重试,次数未用尽则重新订阅上游。
  3. 重试成功继续发射;用尽后异常向下游传播。
  4. 取消异常直接放行,不进入重试。

代码或图示

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 只观察。

原理流程

  1. 上游正常发完,cause 为 null 触发回调。
  2. 上游异常终止,cause 携带异常。
  3. 收集协程取消,cause 携带取消异常。
  4. 回调内可清理订阅、记录结束日志。

代码或图示

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 合并为一个流。

原理流程

  1. channelFlow 建立通道与收集协程。
  2. 内部 launch 多个生产者协程向通道 send。
  3. 通道把值串行交给下游。
  4. 流取消时子生产者随作用域取消。

代码或图示

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 元素类型去掉可空。
  • 相邻去重:只比较当前与上一个,不是全局去重。
  • 两者都是中间冷操作符。

原理流程

  1. filterNotNull 判断非空才向下游发送。
  2. distinctUntilChanged 记录上一个发射值。
  3. 当前值等于上一个则忽略,不等则放行并更新记录。
  4. 自定义相等可用谓词或键选择器。

代码或图示

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 用于确定唯一结果的校验场景。

原理流程

  1. 元素流过限长操作符计数。
  2. take/drop 达到条件后放行或结束。
  3. first 取到值后取消收集协程。
  4. 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 用首元素作初值。

原理流程

  1. 调用末端操作符启动收集。
  2. 元素逐个累加/收集到目标结构。
  3. 流结束返回结果。
  4. 中途异常沿收集协程传播。

代码或图示

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 形成多段调度边界。

原理流程

  1. flowOn(dispatcher) 在上游与下游间插入通道。
  2. 上游操作符在指定 Dispatcher 运行并发 send 到通道。
  3. 下游从通道取值,运行在收集协程上下文。
  4. 多次 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) 边界包裹。
  • 违反上下文约束可能导致取消与异常不可控。

原理流程

  1. 收集协程上下文沿链传递。
  2. flowOn 合法地在上游段替换 Interceptor。
  3. 收集器内手动开线程脱离 Job 父子链。
  4. 取消无法到达手动线程,资源泄漏风险。

代码或图示

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(零缓冲)顺序调用。

概念解释

  • 缓冲解耦上下游执行节奏。
  • 通道容量可配,满了按策略处理。
  • 适合生产快、消费慢且允许排队的场景。

原理流程

  1. buffer 建立通道,上游 send 到通道。
  2. 下游从通道取数处理。
  3. 通道未满上游可继续,满则挂起或按溢出策略处理。
  4. 流取消时通道与上下游一起终止。

代码或图示

source.buffer(Channel.BUFFERED).collect { slowProcess(it) }

常见误区

  • 对要求实时最新值的流盲目 buffer:旧值积压延迟刷新。
  • 缓冲无上限导致内存增长:需评估容量与溢出策略。

追问

  • buffer 与 flowOn 的关系?答:flowOn 内部已带缓冲通道;显式 buffer 可再调整容量。
  • 缓冲大小如何选?答:按生产消费速率差、内存预算与时效性确定。

04.8.2.2-019 conflate 与 collectLatest 都丢弃中间值,差别是什么?

一句话结论

conflate 保留通道最新值:下游慢时上游持续发,下游只拿得到最新快照,不取消正在执行的下游处理;collectLatest 新值到达时取消上一个仍在执行的下游处理块,重新对新值执行,适合「只关心最新结果」的处理。

概念解释

  • conflate:上游不中断,合并最新值,下游串行处理最新项。
  • collectLatest:下游处理器可被新值取消重启。
  • 两者都降低积压,但取消语义不同。

原理流程

  1. conflate 通道策略为保留最新,旧值被覆盖。
  2. 下游取最新值处理,处理期间新值继续覆盖。
  3. collectLatest 每个值启动新处理协程。
  4. 新值到达取消上一个处理协程,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 挂起直到下游处理完当前元素,下游慢直接反压到上游;没有自动丢值或无限排队,需要缓冲、合并或最新值策略时显式使用对应操作符。

概念解释

  • 背压:上游速度受下游处理能力约束。
  • 默认策略是顺序等待,不丢弃。
  • 缓冲/合并/最新值是可选的背压调整。

原理流程

  1. 上游 emit(x) 调下游处理。
  2. 下游未返回前上游挂起。
  3. 下游完成,上游继续下一值。
  4. 插入 buffer/conflate 后才改变排队或丢值行为。

代码或图示

// 默认:下游慢则上游在 emit 点挂起
source.collect { process(it) }

常见误区

  • 以为 Flow 自带无限队列:默认零缓冲,不会积压无限多元素。
  • 以为下游慢会自动丢值:默认保留顺序不丢。

追问

  • 阻塞下游会卡住上游吗?答:会,同链顺序执行;应把阻塞任务移到独立调度边界。
  • 背压策略在 Channel 上如何表达?答:容量与溢出策略组合,见 Channel 章节。

04.8.2.2-021 Channel 在协程间传递数据时扮演什么角色?

一句话结论

Channel 是协程间通信的队列:生产者 send 元素,消费者 receive/迭代接收;它解耦发送与接收节奏,自带容量、挂起等待与取消传播,是 Flow 与 produce/actor 的底层通道原语。

概念解释

  • 协程间通过通道传值,不直接共享可变状态。
  • 通道关闭表示不再有元素。
  • 通道挂起在满/空时等待,不占自旋线程。

原理流程

  1. 创建指定容量与策略的 Channel。
  2. 生产者 send:未满入队,满则挂起或按策略处理。
  3. 消费者 receive:有值取走,空则挂起等待。
  4. 关闭后消费者收到结束信号;取消时通道随作用域终止。

代码或图示

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:无限排队,受内存约束。

原理流程

  1. 创建通道时选容量类型。
  2. 生产者 send 按容量入队或挂起/覆盖。
  3. 消费者按容量语义取数。
  4. 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:保队列内已有值,拒收新值。
  • 策略在通道构造时传入。

原理流程

  1. 通道按容量维持队列。
  2. send 时队列未满直接入队。
  3. 已满:SUSPEND 挂起;DROP_OLDEST 弹出旧值;DROP_LATEST 放弃新值。
  4. 消费者取走元素后队列释放槽位。

代码或图示

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;两侧状态分离,避免提前误判无数据。

概念解释

  • 关闭是通知结束,不删队列残留。
  • 发送关闭后消费者可取完积压值。
  • 两个布尔属性分别反映两侧状态。

原理流程

  1. 生产者调用 close,发送侧置关闭。
  2. 已入队元素继续被 receive 取走。
  3. 队列空且发送关闭,接收侧置关闭。
  4. 消费者遍历通道时收到结束信号退出循环。

代码或图示

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。
  • 生产者协程随作用域结构化管理。

原理流程

  1. produce 在作用域内启动生产者协程。
  2. 块内 send 元素到内部通道。
  3. 返回 ReceiveChannel 给消费方。
  4. 作用域取消时生产者与通道一并终止。

代码或图示

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 双向通道配合。

原理流程

  1. actor 启动单协程持有私有状态。
  2. 外部向其发送消息到通道。
  3. 协程串行接收并更新状态。
  4. 状态访问全部经消息队列,天然互斥。

代码或图示

// 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 处理空与关闭。
  • 通道消费关系影响能否复用通道。

原理流程

  1. 消费者进入遍历循环。
  2. 每取一个元素处理。
  3. 通道关闭排空后循环退出。
  4. 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 面向协程间消息传递与流式背压。

概念解释

  • 挂起等待:不占线程。
  • 取消传播:通道随作用域终止。
  • 消息语义:发送/接收配对,可关闭通知结束。

原理流程

  1. 满通道 send 挂起当前协程,线程释放。
  2. 消费者取走元素,唤醒等待发送者。
  3. 协程取消时通道等待者一并取消。
  4. 线程队列则依赖锁阻塞唤醒机制。

代码或图示

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、初始值、状态去重。
  • 两者上游独立于订阅者存活。

原理流程

  1. SharedFlow 配置 replay 与缓冲,新订阅者先收缓存重放。
  2. 新值发给所有活跃订阅者。
  3. StateFlow 内部维护状态值,更新时去重后广播。
  4. 订阅关系不影响上游生产者存活。

代码或图示

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。

原理流程

  1. MutableSharedFlow 构造时指定 replay 与缓冲。
  2. 新值写入缓存与广播列表。
  3. 新订阅者订阅时先重放 replay 个最近值。
  4. 之后接收实时新值。

代码或图示

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:广播流,可配置重放。
  • 启动策略:懒订阅开始、首个订阅开始或立即开始。

原理流程

  1. 指定上游冷流与共享 Scope。
  2. stateIn 维护状态值,shareIn 维护缓存与订阅者。
  3. 按启动策略订阅上游。
  4. 上游在共享 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 在内部保证基于最新值计算。
  • 相等的新值不会触发新的广播。

原理流程

  1. update lambda 接收当前状态。
  2. 返回新状态,内部 CAS 尝试更新。
  3. 冲突时重试读取最新值重算。
  4. 新值与旧值相等则不通知订阅者。

代码或图示

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 中保留多条。

原理流程

  1. 订阅者连接到 StateFlow。
  2. 立即发射当前 value。
  3. 后续状态更新按 equals 比较发射。
  4. 无新值时订阅者不被重复唤醒。

代码或图示

viewModel.state.collect { screen -> render(screen) }
// 进入收集即拿到当前状态

常见误区

  • 用 StateFlow 发「点击后跳转」这类事件:重新进入页面/重复订阅会再次收到旧状态。
  • 以为订阅前更新的历史都能收到:只有当前快照,不是历史序列。

追问

  • 一次性事件用什么承载?答:SharedFlow(replay=0) 或单向事件通道。
  • 状态与事件如何共存?答:StateFlow 放界面状态,SharedFlow 放单次事件。

04.8.2.2-034 SharedFlow 订阅者数量与上游有什么关系?

一句话结论

SharedFlow 上游是否运行取决于启动策略:WhileSubscribed 在有订阅者时启动、全部退出后停止;Eagerly/Lazily 按策略在作用域内常驻;订阅者数量变化只影响广播分发,不改变冷流上游在未共享前的执行次数。

概念解释

  • 共享上游独立于个别订阅者。
  • 订阅计数驱动条件启动策略。
  • 作用域取消时上游终止。

原理流程

  1. shareIn 指定 SharingStarted 与 Scope。
  2. 订阅者增减更新计数。
  3. WhileSubscribed 按计数上下线上游。
  4. 上游值分发给所有活跃订阅者。

代码或图示

val shared = source.shareIn(
    scope,
    SharingStarted.WhileSubscribed(stopTimeoutMillis = 2000),
    replay = 1
)

常见误区

  • 以为每个订阅者都重跑一遍上游:共享模式下上游只有一份。
  • 以为订阅者退出会清空 replay 缓存:缓存按配置保留。

追问

  • WhileSubscribed 超时停止的作用?答:全部订阅退出后延迟停止上游,避免频繁上下线抖动(超时参数以版本为准)。
  • 多订阅者收到值顺序一致吗?答:按广播顺序分发,各订阅者处理节奏独立。

04.8.2.2-035 热流的取消与生命周期由谁管理?

一句话结论

热流的生产者生命周期由创建时传入的 CoroutineScope 管理:Scope 取消则上游终止、流结束;单个订阅者取消只断开自己的收集,不停止共享上游;状态/事件流在组件销毁时随 Scope 一起取消。

概念解释

  • 热流不依附单次 collect。
  • 上游 Job 挂在共享 Scope 下。
  • 订阅者取消是局部断开。

原理流程

  1. stateIn/shareIn 使用传入 Scope 启动上游。
  2. 订阅者 collect 取消只停止自己的收集协程。
  3. Scope.cancel() 取消上游 Job,流广播结束。
  4. SharedFlow 缓存随上游生命周期释放。

代码或图示

// viewModelScope 销毁时自动取消共享上游
val state = source.stateIn(viewModelScope, SharingStarted.Lazily, idle)

常见误区

  • 取消一个 collect 就以为上游停了:共享上游继续服务其他订阅者。
  • 用 GlobalScope 持有热流:生命周期脱离页面/应用边界。

追问

  • 上游异常后热流还能继续吗?答:上游失败终止流,需重建共享实例或重试设计。
  • 组件销毁如何释放订阅?答:在生命周期作用域内 collect,取消随销毁自动传播。

04.8.2.2-036 buffer 指定容量后上下游如何交换元素?

一句话结论

buffer(capacity) 在上下游间建指定容量的通道:上游把元素 send 到通道,下游从通道取;通道未满时上下游可并行推进,满了上游按默认 SUSPEND 背压等待,容量决定排队上限。

概念解释

  • 容量是通道槽位数,不是历史重放缓存。
  • 上下游解耦后在不同协程中运行。
  • 溢出行为可通过通道策略配置。

原理流程

  1. buffer 创建容量为 n 的通道。
  2. 上游协程 send 入队。
  3. 下游协程 receive 出队处理。
  4. 队满上游挂起,队空下游挂起,随消费/生产唤醒。

代码或图示

source.buffer(16).collect { process(it) }

常见误区

  • 以为 buffer 容量越大越快:过大占内存,且不能突破下游处理能力。
  • buffer 与 replay 混淆:buffer 是运行期排队,replay 是热流订阅重放。

追问

  • 不指定容量的 buffer 用什么策略?答:使用库默认缓冲配置,具体默认值以版本文档为准(待确认)。
  • 多个 buffer 串联会叠加队列吗?答:相邻缓冲操作符各自建通道,容量分段累加。

04.8.2.2-037 下游处理慢时,缓冲、合并、最新值三种策略如何选?

一句话结论

不能丢且要求完整顺序用 buffer(配合背压);允许丢弃中间过程、只保留最新快照用 conflate;每次都要对最新值重新发起异步处理用 collectLatest;按「能否丢值、是否保序、可否取消旧任务」三个维度选型。

概念解释

  • buffer:完整保留,排队等待。
  • conflate:保最新,不取消进行中的下游处理。
  • collectLatest:可取消旧处理,切换到最新任务。

原理流程

  1. 评估业务:事件不可丢选 buffer。
  2. 中间状态可覆盖选 conflate。
  3. 旧任务结果无价值且可中断选 collectLatest。
  4. 监控队列长度与丢弃情况验证策略。

代码或图示

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 内实现。

原理流程

  1. conflate 通道只保留最新元素。
  2. 新值覆盖旧值,下游取最新。
  3. DROP_LATEST 场景需自建通道策略。
  4. 丢弃决定在生产者入队时做出。

代码或图示

// 保最新:conflate
source.conflate()
// 自定义策略:channelFlow + Channel 配置
channelFlow { /* send 配合自定义通道策略 */ }

常见误区

  • 以为所有通道策略都有同名 Flow 操作符:并非一一对应。
  • 依赖操作符内部队列行为做精确时序假设:版本实现可能调整。

追问

  • 如何观测被丢弃的元素?答:在自定义通道/操作符内计数埋点,操作符本身不返回丢弃通知。
  • conflate 的重放语义?答:它不跨订阅重放,仍是冷流。

04.8.2.2-039 生产速率远高于消费速率时如何防止内存膨胀?

一句话结论

先评估能否降产(限流、采样、合并),再设置有界缓冲与明确溢出策略;关键事件落库或持久化队列后异步消费;避免 UNLIMITED 缓冲与无界 replay,监控队列长度并在背压超阈值时降级。

概念解释

  • 内存膨胀来自无界排队的元素对象。
  • 降产:上游只产出必要粒度。
  • 持久化:不可丢事件先落盘再消费。

原理流程

  1. 统计生产/消费速率差与单元素大小。
  2. 设有界缓冲与溢出策略。
  3. 关键事件持久化兜底。
  4. 队列超阈值触发限流或降级,避免 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:通道解耦并发发送。
  • 两者都是冷流,订阅时激活。

原理流程

  1. channelFlow 创建内部通道与收集作用域。
  2. 块内启动多个子生产者 send 到通道。
  3. 通道值串行交给下游。
  4. 流取消时子生产者随作用域终止,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 的回调特化。
  • 回调线程与协程线程不同,经通道转交。
  • 反注册是取消路径上的必要清理。

原理流程

  1. 块内注册监听器到旧式回调 API。
  2. 回调到达时 trySend 元素到通道。
  3. 订阅取消,awaitClose 回调执行反注册。
  4. 通道关闭,流结束。

代码或图示

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 释放外部订阅、句柄的标准位置,不在元素流路径上执行。

概念解释

  • 清理回调在流终态触发。
  • 可能在任意线程执行。
  • 多次订阅各自注册与清理配对。

原理流程

  1. 生产者块注册 awaitClose 动作。
  2. 流正常结束或取消。
  3. 通道关闭,触发清理回调。
  4. 反注册外部回调、释放资源。

代码或图示

callbackFlow {
    val sub = observe()
    awaitClose { sub.dispose() }
}

常见误区

  • 把业务值发射放进 awaitClose:它只做清理,不发射元素。
  • 假设 awaitClose 在订阅者线程执行:线程由关闭触发上下文决定。

追问

  • 流正常完成还会调 awaitClose 吗?答:会,关闭路径统一触发清理。
  • 清理动作需要挂起怎么办?答:回调内不能直接挂起,可用独立不可取消作用域完成必要释放。

04.8.2.2-043 Flow 取消如何从 collect 传播到上游回调?

一句话结论

collect 协程取消时取消信号沿操作符链到达 channelFlow/callbackFlow 作用域,块内子生产者随之取消,awaitClose 执行反注册;旧式回调 API 若不支持主动反注册,需在回调到达时检查流是否已关闭并丢弃值。

概念解释

  • 取消沿父子 Job 链与流链双向传播。
  • 桥接层要把协程取消映射为外部订阅释放。
  • 已取消通道的 send 不会再到下游。

原理流程

  1. 收集协程被 cancel。
  2. 链上各操作符响应取消。
  3. channelFlow 子生产者取消,awaitClose 反注册。
  4. 迟到的回调检查通道关闭状态,丢弃结果。

代码或图示

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 使用。

原理流程

  1. 注册多个等待分支到 select。
  2. 任一通道有值/Deferred 完成,分支就绪。
  3. select 选择先就绪分支执行。
  4. 返回分支结果,其余分支取消等待。

代码或图示

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:非阻塞探测,结果状态需判断。
  • 关闭通道后两者都返回关闭结果。

原理流程

  1. send 检查通道容量,满则挂起注册等待。
  2. trySend 立即尝试入队,返回结果对象。
  3. 消费者取走元素唤醒等待 send。
  4. 关闭后 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。
  • 用于循环判断通道是否排空关闭。

原理流程

  1. 消费者调 receiveCatching。
  2. 有值返回成功结果。
  3. 通道关闭返回关闭结果。
  4. 循环用 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 协程竞争空闲元素。
  • 分发顺序与消费者等待状态有关。

原理流程

  1. 元素入队或等待接收者。
  2. 多个接收协程注册等待。
  3. 一个元素唤醒一个接收者。
  4. 其余继续等待下一元素。

代码或图示

repeat(4) {
    scope.launch { while (true) handle(channel.receive()) }
}

常见误区

  • 用普通 Channel 做事件广播:每个订阅者收不到完整副本。
  • 期待固定轮询分配:实际按唤醒竞争顺序。

追问

  • 想每个订阅者独立收全量怎么做?答:SharedFlow 广播,或 produce 为每个订阅者创建独立通道。
  • 多消费者如何保证任务不重复?答:通道元素一旦被取走即移除,消费方幂等兜底。

04.8.2.2-048 Channel 的「 rendezvous(会合)」语义在什么场景有用?

一句话结论

RENDEZVOUS 零缓冲要求发送与接收配对才通过元素,发送者挂起直到接收者到达,适合严格的握手式任务交接、不允许排队积压的同步点;常规数据流通常需要缓冲或合并策略。

概念解释

  • 零容量,无元素停留槽位。
  • 发送接收直接配对传递。
  • 上下游节奏被强制对齐。

原理流程

  1. send 时无等待接收者则挂起。
  2. 接收者到达,元素直接交接。
  3. 交接完成双方继续。
  4. 没有中间队列,不保存历史值。

代码或图示

val handoff = Channel<Work>(Channel.RENDEZVOUS)

常见误区

  • 高频事件用 rendezvous:发送者大量挂起等待,吞吐受限。
  • 以为会合通道能缓存突发流量:不能。

追问

  • rendezvous 与 Unconfined 调度有关吗?答:无关,容量策略独立于调度器。
  • 握手场景失败如何取消?答:通道随作用域取消,等待双方收到取消信号。

04.8.2.2-049 通道异常关闭与正常关闭在消费侧有何表现?

一句话结论

正常 close() 后消费者取完残留值再收到结束信号;带异常的关闭(close(throwable))让接收侧结果携带该异常,可在消费循环中识别并向上传播;通道关闭原因决定下游是正常结束还是失败收尾。

概念解释

  • 正常关闭:结束无异常。
  • 异常关闭:结束携带失败原因。
  • receiveCatching 可读取关闭原因。

原理流程

  1. 生产者判断异常路径,close(cause)。
  2. 残留元素仍可被取走。
  3. 排空后接收结果携带 cause。
  4. 下游按 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 统一管理取消与生命周期。

概念解释

  • 通道并发发送是线程安全的。
  • 多生产者共享一个接收队列。
  • 生命周期需随统一作用域管理。

原理流程

  1. 多个生产者 launch 到同一作用域。
  2. 各自 send 元素到通道。
  3. 通道保证入队互斥与顺序排队。
  4. 消费者取走元素,作用域取消时生产者一并终止。

代码或图示

channelFlow {
    repeat(3) { launch { send(produce(it)) } }
    awaitClose { }
}

常见误区

  • 多个生产者不挂同一作用域:取消时部分生产者悬空。
  • 期望多生产者按固定优先级入队:通道不保证优先级,按到达顺序。

追问

  • 通道容量对多生产者意义?答:限制聚合队列长度,满了按溢出策略反压。
  • 多生产者异常如何汇总?答:各自异常进入通道关闭原因或结果包装,统一在消费侧处理。

04.8.2.2-051 为什么不推荐在普通代码里直接裸用 Channel 管理 UI 事件?

一句话结论

裸 Channel 是单次消费、需手动关闭与取消管理的原语;UI 事件广播、状态暴露更适合 StateFlow/SharedFlow:自带订阅管理、重放缓存与作用域绑定,直接裸用通道容易泄漏订阅、错过新订阅者初始值。

概念解释

  • 通道:工作队列,元素只被消费一次。
  • SharedFlow:多订阅广播,缓存策略可配。
  • StateFlow:单一状态快照。

原理流程

  1. 识别需求:状态、广播事件还是任务队列。
  2. 状态用 StateFlow,广播用 SharedFlow。
  3. 通道保留给协程间任务交接与底层汇聚。
  4. 生命周期统一绑定页面作用域。

代码或图示

// 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 生命周期绑定其作用域。
  • 多副本语义需共享流实现。

原理流程

  1. produce 启动生产者往通道发元素。
  2. 多个收集协程竞争 receive。
  3. 元素被一方取走,另一方不可见。
  4. 需要广播时上游改 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 是转换为热流的特殊操作,按共享策略启动上游。

原理流程

  1. 链式调用中间操作,保存操作符包装。
  2. 末端 collect 启动收集协程。
  3. 上游沿链发射,逐级经过中间操作。
  4. 末端消费结果或汇聚。

代码或图示

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 只拦自己上游的异常。
  • 取消异常沿同一链传播但不应被重试吞掉。

原理流程

  1. 某操作符 lambda 抛异常。
  2. 回溯经过已包装的上层操作符。
  3. 遇到 catch 处理或放行。
  4. 到达 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 有自己的请求协议。
  • 桥接:订阅生命周期与取消需双向映射。

原理流程

  1. 从 RxJava 源桥接为 Flow,订阅时建立上游订阅。
  2. 元素经桥接 send 到 Flow。
  3. Flow 取消时取消 RxJava 订阅。
  4. 反向转换同理,错误与取消相互映射。

代码或图示

// 互操作依赖对应桥接库;坐标与 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 说明。

原理流程

  1. 升级依赖后查看编译警告。
  2. 对照官方迁移说明替换 API。
  3. 行为差异用测试验证。
  4. 不凭记忆保留旧签名。

代码或图示

// 旧通道遍历写法逐步迁移到 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 抽象更高。

原理流程

  1. 数据需求为管道变换:选 Flow 操作符。
  2. 需要通道原语多路等待:保留 Channel。
  3. produce 仅在需要 ReceiveChannel 句柄时使用。
  4. 订阅、取消、异常统一走协程体系。

代码或图示

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 方法。

原理流程

  1. 类内创建 MutableSharedFlow/MutableStateFlow。
  2. 属性类型声明为只读 SharedFlow/StateFlow。
  3. 内部方法调 trySend/update 写入。
  4. 外部订阅只读观察。

代码或图示

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。
  2. 订阅断开,计数 -1。
  3. 观察计数判断是否需要保活上游。
  4. 无订阅时释放昂贵资源。

代码或图示

shared.subscriptionCount.collect { count ->
    if (count == 0) releaseHeavySource()
}

常见误区

  • 把计数当永久在线标志:配置变更/短暂断开会归零再恢复。
  • 无订阅时直接销毁共享实例:可能马上又有新订阅者。

追问

  • WhileSubscribed 是否内部就用订阅计数?答:其策略基于订阅计数与超时管理,实现细节以官方文档为准。
  • 计数为 0 时 replay 缓存还在吗?答:缓存按 SharedFlow 配置保留,不随订阅清空。

04.8.2.2-060 resetReplayCache 在什么场景需要?

一句话结论

MutableSharedFlow.resetReplayCache() 清空重放缓存,用于需要丢弃历史快照、避免新订阅者收到过期状态的场景(如登出后清理上一次会话事件);StateFlow 没有等价的清空 replay 概念,它始终持有当前状态。

概念解释

  • replay 缓存是新订阅者的历史补偿。
  • 切换账号/会话时旧缓存不应带到新上下文。
  • 清空只影响缓存,不影响活跃订阅者已收到的元素。

原理流程

  1. 会话失效,调用 resetReplayCache。
  2. 重放队列清空。
  3. 新订阅者只收到清空后的新值。
  4. 活跃订阅者继续接收实时值。

代码或图示

fun logout() {
    events.resetReplayCache()
}

常见误区

  • 用 resetReplayCache 停止上游生产:它只清缓存,不取消生产者作用域。
  • 对 StateFlow 调用等价清空:状态值需重新赋值为初始状态。

追问

  • 缓存清空后 replay 配置还在吗?答:配置不变,后续新值重新进入缓存。
  • 登出时是否也要取消上游?答:是,按生命周期取消共享 Scope,缓存清理与上游释放分别处理。

04.8.2.2-061 StateFlow 为什么会自动去重,去重依据什么?

一句话结论

StateFlow 发射新值时与当前值用 equals 比较,相等则不更新、不通知订阅者;去重依据是元素相等性,复杂数据类应正确实现 equals(data class 自动生成),引用相等但内容不同的对象需注意比较逻辑。

概念解释

  • 状态流只关心当前快照是否变化。
  • 重复相同状态避免无意义 UI 刷新。
  • 可变对象不实现 equals 可能去重失效或误判。

原理流程

  1. 写入新状态值。
  2. 内部与当前 value 比较 equals。
  3. 相等:丢弃,不广播。
  4. 不等:更新 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 或事件通道。

概念解释

  • 状态可重放,事件只应消费一次。
  • 订阅恢复需要当前快照,事件不需要历史。
  • 两类模型不可互相替代。

原理流程

  1. 事件发生写入事件通道 SharedFlow(replay=0)。
  2. 活跃订阅者收到一次。
  3. 后续新订阅者不收历史事件。
  4. 界面状态另存 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 必须有当前值,不能空。
  • 初始值表达加载前默认界面。
  • 上游失败时状态如何呈现取决于错误处理设计。

原理流程

  1. stateIn 指定初始值与 Scope。
  2. 订阅者先收到初始值。
  3. 上游发射状态,更新当前值。
  4. 后续订阅者收到最新快照。

代码或图示

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:运行期排队缓冲。
  • 总容量影响内存占用。

原理流程

  1. 新值先写入缓冲。
  2. replay 部分保留供新订阅重放。
  3. extra 槽位缓解瞬时速率差。
  4. 满后按溢出策略处理。

代码或图示

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:热状态流,持有当前值。
  • 并发语义:都避免积压旧值。

原理流程

  1. conflate 通道保最新,下游取快照。
  2. 每次 collect 重新执行上游。
  3. StateFlow 内部维护状态,共享给所有订阅者。
  4. 状态去重与初始值由 StateFlow 保证。

代码或图示

source.conflate().collect { }
val state = source.stateIn(scope, SharingStarted.Lazily, idle)

常见误区

  • 以为 conflate 流自动共享一份上游:仍是冷流,多次订阅独立。
  • 用 StateFlow 发高频流式更新:状态去重可能合并非等价中间帧。

追问

  • 高频传感器数据流选哪个?答:需要共享最新快照用 StateFlow;单次订阅处理用 conflate 冷流。
  • StateFlow 能否表达序列历史?答:不能,只保留当前值,历史需自行缓存。

04.8.2.2-066 热流上游异常后,新订阅者会收到什么?

一句话结论

上游失败终止后热流处于结束状态:已订阅者收到结束/失败信号,新订阅者不会重启上游;需要持续可用的流应在共享作用域内实现重试重建,或让状态沉淀为错误 StateFlow,订阅者按结束原因处理。

概念解释

  • 热流生命周期随共享 Scope。
  • 上游异常 = 流终止,不是暂停。
  • 自动恢复需显式重建逻辑。

原理流程

  1. 上游抛异常,共享 Job 失败。
  2. 通道/状态流结束,携带失败原因。
  3. 订阅者 onCompletion/catch 感知失败。
  4. 重建需新的 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 + 取消检查。
  • 封装边界:订阅时建立,取消时释放。

原理流程

  1. 函数返回 Flow,不提前启动数据源。
  2. collect 时注册回调或进入轮询循环。
  3. 元素经通道/emit 交下游。
  4. 取消触发反注册或退出循环。

代码或图示

fun pollingFlow(): Flow<Long> = flow {
    while (currentCoroutineContext().isActive) {
        emit(System.currentTimeMillis())
        delay(1000)
    }
}

常见误区

  • 数据源在类初始化时就启动:破坏冷流按需订阅语义。
  • 轮询循环不检查取消:页面销毁后仍跑定时器。

追问

  • 多个订阅者各起一个轮询是否浪费?答:是,需要共享则用 shareIn 转为热流。
  • 回调多次快速到达会积压吗?答:按通道缓冲/溢出策略处理。

04.8.2.2-068 Flow 链上的副作用应该放在哪一层?

一句话结论

纯数据变换放中间操作符(map/transform),副作用(日志、埋点、写缓存)尽量收敛到末端 collect 或明确的 onEach;中间操作符可能被重试、多次订阅或缓冲执行,副作用位置不当会重复触发或时序错乱。

概念解释

  • 冷流多次订阅,链上副作用会重复。
  • 重试会重跑上游前置副作用。
  • 末端收集是唯一确定的消费落点。

原理流程

  1. 区分变换与副作用。
  2. 变换保持纯函数。
  3. 副作用集中在 collect 或受控 onEach。
  4. 重试/多次订阅时副作用次数可预期。

代码或图示

source
    .map { transform(it) }
    .collect { persist(it) } // 副作用在此

常见误区

  • 在 map 里发网络请求/写库:被重试或重复订阅时重复执行。
  • onEach 副作用假设只执行一次:冷流每次订阅都会跑前置链。

追问

  • 必须在中间层记日志怎么办?答:用 onEach 并注明副作用语义,确认订阅与重试次数。
  • 共享热流上的副作用执行几次?答:上游一份,中间层随共享上游执行一次,下游各订阅独立。

04.8.2.2-069 无限 Flow 在页面销毁时如何保证停止?

一句话结论

无限流(轮询、监听、传感器)必须在绑定页面/组件生命周期的作用域内 collect;作用域取消时取消信号沿链到达上游,轮询 delay 挂起点响应取消,回调源经 awaitClose 反注册;不要用脱离生命周期的全局作用域收集。

概念解释

  • 取消传播从收集协程到上游。
  • 轮询在 delay 点可被取消。
  • 回调源清理依赖 awaitClose。

原理流程

  1. 在 lifecycleScope/viewModelScope 内 collect。
  2. 组件销毁取消作用域。
  3. 取消信号到达无限流上游。
  4. 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:新查询取消旧子流。
  • 异常兜底与状态沉淀分离。

原理流程

  1. 输入文本作为上游 Flow。
  2. debounce 等待输入稳定。
  3. flatMapLatest 调搜索接口,旧请求被取消。
  4. 结果/错误写入 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:周期性发射窗口内最新值。
  • 两者都是时间相关的中间操作符。

原理流程

  1. debounce 收到值后重启静默定时器。
  2. 间隔内无新值,发射最后值。
  3. sample 每到周期边界发射最近一次值。
  4. 无限流取消时定时器随作用域终止。

代码或图示

query.debounce(300).collect { }
sensor.sample(1000).collect { }

常见误区

  • 高频采样用 debounce:结果只在停顿后出现,周期数据丢失。
  • 连续输入用 sample:每个周期都可能发中间输入,未过滤抖动。

追问

  • 两个操作符在空流上行为?答:无值则不发射,流正常结束。
  • 时间基于什么时钟?答:协程调度虚拟时间在测试中可控,真实时间由调度器定时器驱动。

04.8.2.2-072 onStart 与 onCompletion 如何配合流首尾?

一句话结论

onStart 在流开始收集前执行动作(如发射初始值、打开始日志),onCompletion 在流结束(正常/异常/取消)时回调;两者分别包裹流的首尾,配合 catch 可构成完整的开始、结束、异常处理骨架。

概念解释

  • onStart:上游启动前的副作用或前置值。
  • onCompletion:结束原因观察,不兜底发射。
  • 顺序:onStart → 元素流 → onCompletion。

原理流程

  1. collect 启动,先执行 onStart 块。
  2. 上游元素向下游流动。
  3. 结束时 onCompletion 拿到 cause。
  4. 异常路径 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,异常向下游传播。

原理流程

  1. 上游失败进入 retryWhen。
  2. 回调判断异常类型与已试次数。
  3. 可 delay 退避后返回 true 重新订阅。
  4. 返回 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 剩余不满一批的元素。

原理流程

  1. 收集元素累积到缓冲区。
  2. 达到批次条件发射列表。
  3. 流结束发射剩余缓冲。
  4. 取消路径按 finally 决定是否丢弃尾批。

代码或图示

// 数量分批思路:累积到 N 个后整体发射
source.buffer().collect { /* 自行累积并 flush */ }

常见误区

  • 尾批在流取消时被静默丢弃:关键数据需确认 flush 语义。
  • 批次列表可变共享:应每批新建不可变列表。

追问

  • 窗口操作符在哪个包?答:查当前 kotlinx.coroutines Flow 操作符列表,旧/新操作符名以文档为准(待确认)。
  • 批量失败如何重试?答:批次作为整体重试单元,注意幂等性。

04.8.2.2-075 多个 Flow 用 merge 合并后元素顺序如何?

一句话结论

merge 把多个上游 Flow 的元素汇入一个流,结果按各上游到达通道的顺序混合发射,不保证各源之间的先后;需要严格配对用 zip,需要按最新值组合用 combine,merge 只做无顺序约束的汇聚。

概念解释

  • merge:并发收集所有源,到达即发射。
  • 顺序反映各源生产节奏,不是源声明顺序。
  • 任一源失败按流异常规则传播。

原理流程

  1. 为每个上游启动收集协程。
  2. 元素汇入同一通道。
  3. 下游按通道到达顺序取数。
  4. 全部源结束,合并流结束。

代码或图示

merge(sourceA, sourceB, sourceC).collect { }

常见误区

  • 期待 merge 按 A、B、C 轮流出元素:不保证轮询顺序。
  • 用 merge 聚合两个需要配对的字段:应使用 zip。

追问

  • merge 并发度受什么约束?答:各源在共享/各自调度器上运行,通道缓冲与溢出策略影响排队。
  • 某一源慢会拖慢 merge 吗?答:其他源仍发射,慢源只影响自身元素到达节奏。

04.8.2.2-076 冷 Flow 多次订阅为什么上游会执行多遍?

一句话结论

冷 Flow 的收集器 lambda 在每次 collect 时被独立调用,每次订阅建立独立协程与局部状态;共享状态需要显式上提到上游或转为热流,否则两次订阅各自跑一遍网络/数据库读取,产生重复副作用。

概念解释

  • 冷流类似函数:调用几次执行几次。
  • 局部变量不跨订阅共享。
  • 副作用重复是冷流默认语义。

原理流程

  1. 第一次 collect 启动上游协程 A。
  2. 第二次 collect 启动独立协程 B。
  3. 两者各自执行收集器逻辑。
  4. 需要单份共享上游时 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 之后)仍随各订阅独立执行。

概念解释

  • 共享上游:一份生产者。
  • 下游操作符:各订阅者独立管道。
  • 缓存决定新订阅者看到的历史。

原理流程

  1. shareIn 在 Scope 内订阅上游一次。
  2. 上游副作用只发生在共享上游。
  3. 值分发给活跃订阅者。
  4. 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;元素对象本身不变,但执行线程在边界两侧不同,阻塞任务应放在独立上游调度边界,避免卡住下游。

概念解释

  • 通道是跨线程交接的桥梁。
  • 元素序列化/拷贝不是默认行为,直接传引用。
  • 可变对象跨线程共享需自行保证不可变或同步。

原理流程

  1. flowOn 在上游段替换调度器。
  2. 段末元素进入边界通道。
  3. 下游调度器从通道取数恢复续体。
  4. 线程切换发生在通道交接点。

代码或图示

source.flowOn(Dispatchers.IO).collect { /* 收集上下文线程 */ }

常见误区

  • 跨调度器传递可变集合引用:两侧可能并发修改。
  • 假设元素处理线程连续不变:边界两侧线程可能不同。

追问

  • 通道传大对象有拷贝开销吗?答:默认传引用,无深拷贝;对象本身的构造与复制成本另算。
  • 如何确认某操作符跑在哪个线程?答:日志记录线程名与上下文 Dispatcher。

04.8.2.2-079 UI 层收集 Flow 时如何避免主线程积压?

一句话结论

UI 收集协程绑定生命周期,结果更新只做轻量渲染;重计算与阻塞放上游/IO 边界,流用 conflate 或 collectLatest 抑制中间积压;批量数据先在后台分页/裁剪,主线程不做重解析,避免消息循环被长任务卡住。

概念解释

  • 主线程只做视图更新,不做阻塞 IO/重计算。
  • 背压策略防止旧帧积压。
  • 数据量控制减少单帧渲染成本。

原理流程

  1. 上游在后台调度器加载/解析数据。
  2. 流经缓冲/合并策略控制投递节奏。
  3. 主线程 collect 只更新状态与视图。
  4. 页面销毁作用域自动取消收集。

代码或图示

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;取消场景验证上游是否随收集协程取消。

概念解释

  • 测试调度器控制执行与虚拟时间。
  • 收集结果可断言完整序列。
  • 异常与结束原因可分别验证。

原理流程

  1. runTest 内启动收集协程。
  2. 元素收集到 mutableList。
  3. 推进虚拟时间触发定时操作符。
  4. 断言序列、异常类型与取消行为。

代码或图示

@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 的协程被取消时,已经发射到通道缓冲的元素怎么办?

一句话结论

收集协程取消后通道随作用域终止,缓冲中未消费元素按取消语义丢弃(不保证继续交付);关键数据不能依赖缓冲兜底,应在流外部持久化;取消后下游不会再处理残留元素。

概念解释

  • 取消是终止信号,不是优雅排空。
  • 缓冲元素属于内存临时队列。
  • 不可丢事件需落盘或可靠队列。

原理流程

  1. 收集协程 cancel。
  2. 边界通道关闭,等待者收到取消。
  3. 残留元素不再被消费。
  4. 上游在挂起点/检查点停止。

代码或图示

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。
  • 两者都触发冷流订阅。

原理流程

  1. collect 在当前协程沿链处理元素。
  2. launchIn 在 scope 内 launch 收集块。
  3. 收集 Job 挂到 scope 父子链。
  4. 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 通道支持并发生产者。
  • 违反串行契约可能产生不可靠行为。

原理流程

  1. flow{} 内 launch 子协程并发 emit。
  2. 多个续体竞争同一收集器,顺序无保证。
  3. channelFlow 内子协程 send 到线程安全通道。
  4. 通道串行交下游,取消随作用域传播。

代码或图示

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 读:安全可见。
  • 复合读改写:需要原子更新原语。
  • 状态对象本身应不可变,避免内部被并发修改。

原理流程

  1. 任意线程读取当前 value。
  2. 并发更新经 CAS 尝试写入。
  3. 冲突时 update 重试基于最新值重算。
  4. 新值 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。

原理流程

  1. trySend 检查缓冲槽位。
  2. 有槽位入队并广播给订阅者。
  3. 满员按溢出策略处理或返回满结果。
  4. 调用方根据结果决定降级或日志。

代码或图示

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 明确表达。
  • 阻塞与非阻塞段分离。
  • 边界两侧线程不同,状态传递用值对象。

原理流程

  1. 上游调用阻塞旧库,flowOn(IO) 包裹。
  2. 结果变换为不可变 DTO。
  3. 边界通道交到 Main 收集上下文。
  4. collect 内只更新视图状态。

代码或图示

flow { emit(blockingQuery()) }
    .flowOn(Dispatchers.IO)
    .collect { render(it) }

常见误区

  • 在 Main 段调用同步 JDBC/文件读:阻塞消息循环。
  • 跨线程传递可变列表引用:两侧并发修改风险。

追问

  • 非阻塞异步客户端需要 flowOn(IO) 吗?答:不需要靠阻塞线程等待,按其自有调度接入。
  • 阻塞调用失败如何退出流?答:抛异常经 catch 映射错误状态。

04.8.2.2-087 Flow 与回调式接口互操作时,如何避免「回调晚于取消到达」?

一句话结论

桥接层在回调内检查通道/流是否已关闭,已取消则丢弃结果并清理;awaitClose 反注册订阅;对不能反注册的 API 用弱引用与关闭标记,避免回调操作已销毁的页面或重复投递过期结果。

概念解释

  • 取消与回调到达存在竞态。
  • 关闭标记是回调侧的防护判断。
  • 资源反注册在 awaitClose 完成。

原理流程

  1. 订阅回调注册到外部 API。
  2. 流取消,awaitClose 反注册。
  3. 迟到回调到达,检查关闭状态丢弃值。
  4. 弱引用避免长生命周期持有页面对象。

代码或图示

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 操作符不自动跨线程复制任意线程局部变量。

概念解释

  • 线程局部变量不随协程续体自动传播。
  • 数据字段是最可靠的跨边界传递方式。
  • 自定义上下文元素随协程上下文继承。

原理流程

  1. traceId 放入元素 DTO 或上下文元素。
  2. 上游生成后沿流传递。
  3. 跨调度器边界随元素引用传递。
  4. 下游日志读取标识关联链路。

代码或图示

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。
  • 视图作用域收集断开不等于上游销毁。
  • 事件流不缓存断开期间的事件。

原理流程

  1. 旋转重建视图,ViewModel 与其中热流存活。
  2. 新视图订阅 StateFlow 拿到当前状态。
  3. replay=0 事件不补发断开期间事件。
  4. 进程回收时 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:热单值状态,自动去重。

原理流程

  1. 是否需要共享上游:是 → 热流。
  2. 是否只有单一状态快照:是 → StateFlow。
  3. 广播事件与缓存策略:SharedFlow。
  4. 底层任务交接与 select:Channel。

代码或图示

// 管道:Flow;事件广播:SharedFlow;状态:StateFlow;任务队列:Channel

常见误区

  • 所有数据通信都用 Channel:缺少操作符与订阅管理。
  • 所有状态都用 StateFlow:一次性事件被重复消费。

追问

  • 组合使用可行吗?答:可行,如 channelFlow 内部用通道,对外暴露 Flow;状态与事件分层持有。
  • 迁移旧 Channel 代码到 Flow 的步骤?答:先识别消费语义,再映射到 Flow/SharedFlow 对应模型。

04.8.2.2-091 高频定位更新的场景,流策略应如何搭配?

一句话结论

定位/传感器等高频更新用 sample 周期取快照或 conflate 保最新,避免中间值积压;展示层用 collectLatest 在新位置到达时取消旧的渲染/请求;关键轨迹点再批量持久化,不可丢的上报走独立有界队列或持久化通道。

概念解释

  • 高频源需要节奏控制。
  • 旧渲染任务可被新值取消。
  • 持久化与展示分流,互不阻塞。

原理流程

  1. 定位回调经 callbackFlow 进入流。
  2. sample/conflate 控制投递节奏。
  3. collectLatest 刷新界面,旧任务取消。
  4. 关键点写入独立持久化队列异步上报。

代码或图示

locationFlow
    .sample(500)
    .collectLatest { render(it) }

常见误区

  • 每个原始定位点都触发网络请求:请求风暴与旧响应覆盖。
  • 上报队列无界:内存积压,关键轨迹反而丢失。

追问

  • 旧定位请求如何防覆盖?答:请求序号校验,过期响应丢弃。
  • 后台持续定位用什么作用域?答:应用级/服务级 Scope,不依附页面生命周期。

04.8.2.2-092 流中某个元素处理失败,如何不中断整条流?

一句话结论

在元素处理层把失败包装为结果类型(runCatching/密封结果),让失败作为值继续流动;或用 catch 只兜底上游特定异常并 emit 降级值;不要让单元素异常冒泡终止整条流,除非业务要求整体失败。

概念解释

  • 元素级容错:失败不中断序列。
  • 流级 catch:兜底上游异常转为结束/降级。
  • 结果类型让下游显式处理成功失败。

原理流程

  1. 每元素处理包 runCatching。
  2. 结果作为值发射到下游。
  3. 下游分别处理成功与失败项。
  4. 上游源异常用 catch 整体兜底。

代码或图示

source.map { runCatching { process(it) } }
    .collect { result -> result.onSuccess { }.onFailure { } }

常见误区

  • 一条记录失败就中断整个批次流:可恢复场景应隔离失败。
  • catch 把所有异常吞成空值:丢失错误上报与可观测性。

追问

  • 失败元素需要重试怎么办?答:元素级重试在 map 内处理,避免整条流重放。
  • 错误状态如何反映到 UI?答:失败结果写入状态快照或事件流。

04.8.2.2-093 上游缓慢时 StateFlow 是否会积累未处理状态?

一句话结论

StateFlow 只保留当前最新状态,新状态覆盖旧状态,不积压未消费的中间帧;订阅者处理慢时拿到的是最新快照,这与有界缓冲队列不同;代价是中间状态可能被跳过,需要完整历史序列时应使用 SharedFlow/通道。

概念解释

  • StateFlow 单值覆盖模型。
  • 无中间队列积压。
  • 跳过中间值是设计取舍。

原理流程

  1. 新状态写入覆盖当前 value。
  2. 订阅者收到最新值通知。
  3. 未消费的旧中间值被覆盖。
  4. 需要历史时另建缓存或序列流。

代码或图示

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:通道关闭事件驱动的清理。
  • 职责不同,不要互相替代。

原理流程

  1. 协程内资源在 try 块获取,finally 释放。
  2. 外部回调注册在 channelFlow 块内。
  3. 流关闭触发 awaitClose 反注册。
  4. 取消路径两条清理都执行。

代码或图示

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 管订阅。

原理流程

  1. 仓库内构建 MutableSharedFlow 或 shareIn。
  2. 模块在自身 Scope 收集事件。
  3. 模块销毁取消局部收集,不影响共享上游。
  4. 应用退出取消共享上游。

代码或图示

val shared = source.shareIn(appScope, SharingStarted.Eagerly, replay = 0)

常见误区

  • 每个模块各自 shareIn 一份上游:重复生产与副作用。
  • 局部收集时传 GlobalScope:模块销毁订阅不断开。

追问

  • 事件会不会被某个模块消费后消失?答:SharedFlow 广播,各模块独立收全量;Channel 才是竞争消费。
  • 跨模块事件需要类型隔离吗?答:按事件密封类型分层,避免无关模块收到敏感事件。

04.8.2.2-096 为什么不建议在 Flow 收集器内直接抛 CancellationException 之外的业务异常后静默?

一句话结论

Flow 异常沿链传播到收集协程作用域,静默吞掉会破坏错误可观测性与结构化并发;业务失败应转为结果值或经 catch 映射为错误状态,取消异常必须放行,未处理异常应上报到统一兜底处理器。

概念解释

  • 异常是错误信号,需要被记录或展示。
  • 取消异常不能当业务错误吞掉。
  • 结果类型与 catch 是合法的显式容错。

原理流程

  1. 任务内区分取消、业务失败、系统异常。
  2. 可预期失败封装为结果值。
  3. 系统异常经 catch 记录并映射状态。
  4. 未捕获异常冒泡到作用域 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。

概念解释

  • 测试调度器虚拟时钟驱动时间操作符。
  • 手动推进时间触发到期回调。
  • 可断言取消旧任务的清理回调。

原理流程

  1. 测试内构造上游源与被测链。
  2. 发射连续输入。
  3. advanceTimeBy 越过 debounce 窗口。
  4. 断言输出序列与旧子流取消行为。

代码或图示

@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 + 只读集合更安全。
  • 状态更新走复制新对象。

原理流程

  1. 上游产出不可变元素。
  2. 变换阶段复制生成新元素。
  3. 跨边界传递引用但不修改内部。
  4. 下游读取快照渲染。

代码或图示

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 也随版本演进。

原理流程

  1. 确认项目 kotlinx.coroutines 版本号。
  2. 对照官方文档与 KDoc 核对常量与签名。
  3. 运行测试验证行为假设。
  4. 文档中标注待确认点与验证方法。

代码或图示

待确认项示例: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 在页面作用域收集;错误映射为错误状态,取消随页面销毁传播,关键事件与状态分层不混用。

概念解释

  • 状态流:可恢复的界面快照。
  • 事件流:一次性通知。
  • 多源合并基于最新值组合。

原理流程

  1. 各数据源封装为冷 Flow 并处理取消与反注册。
  2. combine 聚合最新值生成 UiState。
  3. stateIn 沉淀状态,SharedFlow 发一次性事件。
  4. 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,分层取消。

参考来源

待整理清单

  • [ ] 核对当前依赖版本下 BUFFERED 默认通道容量的具体数值。
  • [ ] 核对 SharedFlow 溢出策略枚举与 replay/extraBufferCapacity 组合行为。
  • [ ] 核对 consumeEach、旧 actor 扩展在当前版本的废弃标注与替代 API。
  • [ ] 核对 SharingStarted 各策略(Eagerly/Lazily/WhileSubscribed)参数与默认超时。
  • [ ] 整理 Flow 操作符在当前版本的完整分类清单与废弃替代对照。