摘要 第4课聊 effect:当一个值的变化需要“伸到组合外面”去干活——发请求、注册监听、写日志——这份活儿什么时候开始、什么时候被取消、收尾由谁保证。全文从一个反直觉的命题切入:effect API 的存在不是为了让你“能做副作用”,而是为了让你“只能在它划定的圈子里做副作用”。接着从运行时、API、时间、并发、异常、测试、架构七个层面逐层拆解边界,覆盖
LaunchedEffect、rememberCoroutineScope、DisposableEffect、SideEffect、produceState、snapshotFlow、rememberUpdatedState等 API 各自刻意不具备的能力,最后用一套决策框架和 15 道习题把边界钉死。核心原则:effect 不是“在组合里写点代码”,而是组合生命周期上的一份取消与清理合同;知道在哪儿停下来,才算真的会了。
目录
- 开篇回顾:前三课走到了哪里
- 一、为什么不能直接在函数体里写副作用?
- 二、运行时边界:effect 协程的上下文里到底有什么
- 三、API 边界:每个 effect 刻意不具备的能力
- 四、时间边界:取消、重启、配对
- 五、并发边界:effect 之间没有可靠的顺序契约
- 六、异常边界:effect 的异常不会自己变成 UI 错误
- 七、测试边界:effect 是“被驱动的时钟”
- 八、架构边界:effect 是 UI 层的生命周期适配器
- 九、决策框架:别问“用哪个 API”,问边界问题
- 十、习题:15 道边界检验
- 十一、参考答案与解读
- 十二、本节课知识点总结
- 结语
- 下期预告
一个反直觉的命题:effect API 的存在,不是为了让你“能做副作用”,而是为了让你“只能在它划定的圈子里做副作用”。
开篇回顾:前三课走到了哪里
前三课是一条线,从“会写”到“写对”,再到“知道什么不能写”。
第1课讲重组,解决的是“Compose 什么时候调用你的函数”。你接受了函数会被反复调用、跳过、取消的事实:函数体不是顺序执行的脚本,而是一份随时可能被重新求值的声明。
第2课讲稳定性,把镜头拉到类型系统。@Stable、@Immutable 和编译器推断,决定了 Compose 能不能跳过一段组合、相等判断是否可靠。
第3课讲 remember,处理“跨重组保存东西”的问题。remember 保存的是“这个组合位置上的值”,它的生命周期由组合身份定义,而不是由你定义。
这一课讲 effect。前三课的前提汇到一个点上:既然组合体不可靠、类型系统有契约、remember 只管存储不管执行,那么“对外部世界做动作”这件事,该放在哪里、什么时候做、什么时候停?
答案是 effect。但“放在 effect 里”只是起点。真正的深水区是——每一个 effect 在运行时层面究竟被赋予了什么,又被刻意拿走了什么。
一、为什么不能直接在函数体里写副作用?
先看一段“看起来合理”的代码:
@Composable
fun UserScreen(viewModel: UserViewModel) {
viewModel.loadUser()
Text(viewModel.userName)
}
问题不只是“可能调用多次”。更深的问题在于:loadUser() 变成了组合函数“算出界面”这个求值过程的一部分,而这个过程执行几次、什么时候执行,完全由 Compose 运行时决定。官方文档的措辞很克制,指向却很明确:composable 理想情况下应该是无副作用的,因为重组可能以不可预测的方式发生、可能以不同顺序发生,也可能被丢弃。一个不可逆的外部动作绑在一个可能被丢弃的求值过程上,这不是性能问题,是正确性问题。
这里需要精确区分两个概念,因为后面所有 effect 的边界都建立在这个区分之上:“函数体执行”和“进入 Composition”不是一回事。 函数体执行是 Compose 调用你的函数;进入 Composition 意味着这次调用真正被组合、被提交、被记住。一次函数体执行可能最终被跳过、被丢弃,也可能因为父级失效而被重复执行。LaunchedEffect 保证的恰恰是“只在进入 Composition 之后才执行”,而函数体里直接 launch 不具备这个保证。
第一条边界由此确立:函数体只声明 UI、读取状态;外部动作必须交给由 Compose 显式管理的生命周期锚点。
二、运行时边界:effect 协程的上下文里到底有什么
这是大多数教程跳过的部分,但它决定了后面所有 API 边界的技术根基。
当 LaunchedEffect 进入组合时,它把 block 启动到 composition 的 CoroutineContext 中。这个上下文来自 Recomposer 的 effectCoroutineContext。Recomposer 在构造时就要求传入这个上下文,而不是在运行时动态拼凑。在 Android 上,它通常由 AndroidUiDispatcher.Main 及其关联的 MonotonicFrameClock 组成;AndroidUiDispatcher.Main 本身是一个 CombinedContext,同时包含主线程调度器和基于 Choreographer 的帧时钟。
更关键的结构性事实是:LaunchedEffect 和 rememberCoroutineScope 创建的协程,都是 Recomposer 的 effectJob 的子 Job。 它们共享同一套结构化并发层级。由此得到三个直接推论。
下面这张图概括了 effect 协程在 Recomposer 中的结构化并发层级:
第一,默认在主线程恢复。 effect 协程的 ContinuationInterceptor 是 AndroidUiDispatcher,它会在 Handler 回调或 Choreographer 动画帧阶段执行分派,取两者先到者。launch 不等于“后台线程”,它只是“可挂起的异步结构”。需要后台执行时必须显式 withContext(Dispatchers.Default/IO),切回来后的恢复点仍然在主调度器。
第二,CoroutineScope receiver 不是语法糖。 LaunchedEffect 的 block 类型是 suspend CoroutineScope.() -> Unit。你在 effect 里 launch 的子协程是 effect 协程的孩子;effect 被取消,孩子一起走。effect 内部的所有异步工作都归属于这个生命周期锚点,不该逃逸到外部作用域。
第三,取消是协作式的,effectJob 只是发送信号,不会强制终止。 官方文档的表述很简洁:“离开 composition 时协程会被取消”。但 Kotlin 协程的取消需要代码配合:只有在挂起点,或显式检查 isActive / 调用 ensureActive() 时,取消信号才会被响应。一个不响应取消的 effect 等于泄漏:
LaunchedEffect(Unit) {
while (true) { // 条件里没有 isActive
doBlockingWork() // 内部也没有挂起点
}
}
正确的写法是 while (isActive) { ... },或者在循环体内调用 ensureActive()——后者在 Job 已取消时抛出 CancellationException,比 isActive 更适合在深层嵌套中传播取消。如果计算在单个函数内持续执行且没有挂起点,外部取消不会生效,任务会继续占用资源。官方文档中脉冲动画的示例正是用 while (isActive) 配合 delay 来保证可取消性。
异常也走结构化并发的路径。 LaunchedEffect 协程的未捕获异常不会自动变成“重组器错误状态”。它沿协程异常传播路径走 CoroutineExceptionHandler;如果没有处理器,就到达调度器的未捕获异常处理器,在 Android 上通常导致崩溃。Compose 从 1.6 起引入的 CompositionErrorContext 通过 CoroutineExceptionHandler 拦截未被捕获的异常来附加组合位置 trace,但它不改变崩溃行为。
跨平台视角也值得带一句。 Compose Multiplatform 同样依赖 Recomposer 的 effectCoroutineContext,但其具体调度器组合因平台而异。effect 的语义边界(子 Job、协作式取消、异常传播)是跨平台一致的,调度器实现不是。理解这一点,才能在 Desktop、iOS 上不把“默认主线程”当成理所当然。
三、API 边界:每个 effect 刻意不具备的能力
LaunchedEffect:key 是缰绳,不是装饰
契约:进入组合时启动;key 变化时取消旧协程、启动新协程;离开组合时取消。
LaunchedEffect 的生命周期与 key 的关系可以这样理解:
边界一:表达不了进程级“只执行一次”。 LaunchedEffect(Unit) 的“一次”是相对于当前组合实例的。导航离开再返回、条件分支重新进入,effect 都会再执行。它不等同于业务去重。
边界二:不能用于响应回调事件。 官方 API 文档明确写道:不应把回调数据存入 MutableState 再作为 key 传入来“重启”进行中的任务;响应事件应使用 rememberCoroutineScope。原因在于 key 变化会取消并重启整个协程,而事件通常期望“在当前生命周期内追加一个动作”,不是“杀掉之前所有逻辑重来”。
边界三:key 的比较是 equals,选 key 就是立契约。 把 MutableState 对象本身而非 .value 作为 key,引用不变,effect 永不重启。可变对象作为 key 而其 equals 不稳定,会导致该重启时不重启。key 应该是稳定的、不可变的、语义上代表“这件事依赖的输入”的值。更进一步,effect body 中读取的每一个会变化的变量,原则上都应该出现在 key 里;否则你依赖的是闭包捕获的旧值,而不是声明式的“输入变化驱动重启”。
边界四:替代不了业务层。 官方文档在讲 effect 时专门警告:由于 effect 的可能性很广,“很容易被过度使用”,effect 中的工作应该与 UI 相关,并且不破坏单向数据流。用 LaunchedEffect(keyword) 承载防抖、请求、错误映射、缓存、重试,短期能跑,长期把网络策略与 UI 生命周期焊死。防抖可以留在 effect 里,因为它是 UI 输入节奏的建模;但请求、错误分类、缓存属于 ViewModel 或 Repository。
重启的代价必须纳入 key 的设计。 建立 WebSocket、初始化重型资源时,每次 key 变化都是一次昂贵的拆除和重建。不能接受时,用 rememberUpdatedState 把易变依赖移出 key,或把连接生命周期上移到 ViewModel。
一句话:LaunchedEffect 擅长“当输入变化时重新做一件事”,不擅长“只做一次”,也不擅长“响应一次点击”。
rememberCoroutineScope:和 LaunchedEffect 的分界是“谁拥有生命周期”
二者分界不是“异步还是同步”,而是触发源。状态或生命周期驱动的工作走 LaunchedEffect;事件回调驱动的工作走 rememberCoroutineScope。
官方 codelab 有一个精确的反例:
@Composable
fun LandingScreen(onTimeout: () -> Unit) {
val scope = rememberCoroutineScope()
scope.launch { // 错误
delay(3000)
onTimeout()
}
}
rememberCoroutineScope 加 launch 写在函数体里,Compose 每次调用 LandingScreen 都会执行它,无论这次调用是否真正进入 Composition。LaunchedEffect 保证只在进入组合之后才执行——这正是它存在的理由。反过来,在 openDrawer 这样的普通回调里无法调用 LaunchedEffect,因为回调发生时你不在组合上下文中,无法调用 @Composable 函数。
还有一个容易被忽略的细节:rememberCoroutineScope 返回的 scope 在组合离开后会被 cancel。如果在这个 scope 里启动的子协程失败了,scope 的 Job 会以对应异常失败,后续无法再启动子任务。这意味着这个 scope 不是“随便用的全局作用域”,它的生命周期和失败语义都绑定在组合位置上。
一句话:它是给事件回调用的,不是给“进入页面时做点什么”用的。
DisposableEffect:onDispose 是强制契约
DisposableEffect 要求 onDispose 作为 effect 块的最后一条语句;不需要清理的操作不应使用它。官方文档的定义很直白:用于需要在 key 变化后或 composable 离开 Composition 后进行清理的副作用。这个强制结构本身就是边界信号:它只用于成对的注册和注销。
配对语义。 key 变化时,旧 onDispose 用旧闭包执行,新 effect 用新值注册。onDispose 必须释放本次 effect 块注册的那个资源,不是“当前最新的资源”。在 onDispose 里读外部可变状态来“找要释放的东西”,快速切换时会释放错对象。
同步、短小、不抛异常。 effect 块和 onDispose 都在组合的 apply 调度器上运行,且 applier 从不与自身并发执行。这意味着 onDispose 是同步的、不能挂起。它不应启动新的挂起工作、做长时间阻塞,或执行可能抛异常的逻辑。onDispose 的异常会传播到 apply 过程,可能破坏整个组合的提交。
不能依赖协程已停止。 需要精确表述:applier 本身不并发,但 LaunchedEffect 协程的取消是另一个独立过程——onDispose 是同步调用,协程 cancel 是发送信号,协程可能在某个挂起点才响应。如果 onDispose 释放的资源正被一个尚未响应取消的 effect 协程使用,竞态仍然存在。正确做法是资源所有权单一化:要么归 DisposableEffect 管,要么归 LaunchedEffect 管,不让两者共享同一资源的生命周期。
一句话:没有清理,就没有资格用它;清理必须和注册严格配对。
注册与注销的配对关系,是 DisposableEffect 唯一正确的使用形态:
SideEffect:跟着“每次提交”跑,不跟着“每次变化”跑
SideEffect 在每次成功 apply 之后执行,同步、不能挂起、每次提交都会跑。它适合的场景很窄:把 Compose 状态同步到不理解快照系统的外部对象——传统 analytics、日志、命令式 SDK。
常见越界:
SideEffect {
analytics.track("scroll", listState.firstVisibleItemIndex)
}
滚动触发重组,每次重组提交后都会写一次 analytics,频率远高于“值真正变化”的频率。正确做法是 snapshotFlow { listState.firstVisibleItemIndex }.distinctUntilChanged()。SideEffect 反应的是“一次成功提交”,不是“一次有意义的变化”。
关于顺序:当前实现中,同一次 apply 内先分发 onForgotten(含 onDispose),再分发 onRemembered,最后执行 SideEffect。这个顺序直觉合理,但官方并未把它作为稳定契约承诺。把它当作理解行为的参考是安全的,当作正确性的保证就越界了。
produceState:源码层面的三个边界
produceState 的源码很直白:
val result = remember { mutableStateOf(initialValue) }
LaunchedEffect(key1) {
ProduceStateScopeImpl(result, coroutineContext).producer()
}
return result
由此得到三个精确的边界。
第一,key 变化不重置 initialValue。 remember 没有 key,所以 key 变化时 producer 重启,但 State 保留上一次的值,initialValue 不再生效。这不是理论边缘情况。官方 issue tracker 上有一个被标记为“Bug WAI”(Working As Intended)的案例,开发者记录得非常具体:图片加载器用 produceState 加载不同 URI 的图片,切换 URI 时如果新图片加载失败,界面仍然显示上一张图片,因为 State 没有被重置;更严重的一个例子是聊天应用中,切换房间时 produceState 返回了旧房间的加密会话,导致新房间的消息被旧会话解密,房间 ID 校验被触发。官方在 issue 中的回应和 Slack 讨论中的建议是一致的:想要重置行为,可以用 key(...) { } 包裹 produceState;反过来,如果改变 produceState 默认行为,那些依赖“保留旧值”的场景会更难写。修复方式是在 producer 开头显式 value = initialValue,或者在外部用 key() 强制重建状态。
第二,返回的 State 会合并值。 官方 API 文档明确:如果设置的值与旧值 equals,不会产生可观察的变化;快速连续设置多个值时,观察者可能只看到最新的值;这一行为可以通过提供 SnapshotMutationPolicy 来改变。所以 produceState 建模的是“状态”,不是“事件”。一次性消息、导航事件应该走 LaunchedEffect 收集 SharedFlow 或 Channel;用 produceState,中间发射会被静默吞掉。
第三,producer 的异常不会自动变成错误状态。 producer 抛异常,协程失败,State 停在最后的值上,UI 可能永远停在加载态。producer 内部必须 try/catch,把错误建模为状态。
一句话:它是把异步源桥接成“当前状态”的,不是桥接成“事件流”的。
snapshotFlow:只读快照上的观察通道
snapshotFlow 的 block 在只读快照中运行。官方 API 文档的表述没有余地:如果 block 尝试修改快照数据,Flow 收集会以 IllegalStateException 失败。对于相同的输入集,block 可能运行多次,也可能在多次快速变更后只运行一次;它应该具有幂等性且没有副作用。
发射语义由 equals 决定。它只在结果与上一次不相等时发射,行为类似于 distinctUntilChanged()。T 的 equals 实现直接决定发射行为,equals 不稳定会导致漏发或重发。
官方文档在这里做了一个比大多数教程更深的区分,值得完整理解:事件和状态是不同的建模对象。snapshotFlow 把快照变化建模为事件,但事件不能被有效建模为可观察状态。可观察状态是对产生它的事件的“有损压缩”;状态变化事件会被合并,只有最新状态重要,状态观察者必须是幂等的,跳过中间状态或对同一状态运行多次都是合法的。这解释了两件事:为什么 snapshotFlow 需要 equals 去重,以及为什么它不能替代事件流。状态是“现在是什么”,事件是“发生过什么”;snapshotFlow 发射的是状态变化事件,但下游消费的语义必须按状态来设计,而不是按“每一个事件都必须被消费”来设计。
它是观察通道,不是同步屏障。snapshotFlow 发射新值之后,组合树可能尚未反映对应状态。下游写操作仍然需要自己的并发控制。“转成 Flow”不等于“自动线程安全”。
一句话:它是让你“观察状态变化”的桥,不是让你“等待 UI 更新完成”的屏障。
rememberUpdatedState:闭包捕获的精确补丁
rememberUpdatedState 的实现是对 mutableStateOf 执行 remember,并在每次重组时把值更新为 newValue。它产生一个稳定的 State 对象引用,effect 持有这个引用,读 .value 永远是最近一次重组提交的值。
官方文档给出的使用条件很精确:当参数或在组合期间计算的值被一个长期存在的 lambda 或对象表达式引用时,应使用它。重组会更新 State,而不重新创建长期对象,使该对象得以持续存在,而不被取消和重新订阅。
val currentOnEvent by rememberUpdatedState(onEvent)
LaunchedEffect(connectionId) { // 只在 connectionId 变化时重连
connect(connectionId) { msg ->
currentOnEvent(msg) // 永远调用最新回调,但不重启连接
}
}
边界:它只保证“读到最新值”,不保证“最新值在 effect 启动时已经就绪”,也不解决 effect 内部对旧值的其他依赖。它是闭包捕获问题的补丁,不是状态同步的万能药。
生态里的边界工具
LifecycleEventEffect / LifecycleStartEffect / LifecycleResumeEffect(来自 lifecycle-runtime-compose)把 effect 的锚点从 Composition 扩展到 LifecycleOwner 的生命周期事件,用于“进前台/后台”的成对逻辑;LifecycleResumeEffect 还提供 onPauseOrDispose 块用于清理。collectAsStateWithLifecycle 不是 effect,但它是“UI 状态流不应在后台空转”的默认答案:官方明确建议用它在非活跃状态下停止收集连续数据流。
key() 改变时,旧子树的 effect 被取消、新子树重建。movableContentOf 把 content 移动到新位置时,将已记住的状态和已创建的节点一起移动,组合身份保持不变,effect 不重启。这说明 effect 的“离开/进入组合”判定基于组合身份,而非 UI 位置。
四、时间边界:取消、重启、配对
取消是硬边界,不是礼貌请求。 effect 里的阻塞调用尽量换成可取消的挂起版本;while 循环用 isActive 或 ensureActive();collect 的下游处理如果很慢,要考虑它会不会拖住取消。不响应取消的 effect 等于泄漏。Compose 文档中那个脉冲动画的示例之所以用 while (isActive) { delay(...); animateTo(...) },正是因为 delay 提供了挂起点,isActive 提供了循环边界,两者缺一不可。
重启有代价,key 设计要算成本。 防抖、切换数据源是完美机制;建立连接、初始化重型资源是昂贵重建。不能接受成本时,把易变依赖移出 key,或把资源生命周期上移。
清理与注册严格配对,一个资源一个所有者。 别在 onDispose 里“补救”本该在 effect 块里完成的注册,也别在 effect 块里注册资源却把释放留给别的 effect。
测试环境里,时间是被显式驱动的,而且这条边界在近期版本中收紧了。 MainTestClock 驱动帧、重组和 launched effects。LaunchedEffect 里的 delay 不会真实等待,需要 advanceTimeBy 显式推进。一个重要的迁移细节:Compose 1.11.0(2026 年 4 月 release)起,v2 测试 API 成为默认,v1 已弃用;测试调度器从 UnconfinedTestDispatcher(协程立即执行)切换为 StandardTestDispatcher(协程进入队列,直到虚拟时钟推进才执行)。这意味着 effect 中的协程不再自动推进,必须在状态变更后显式调用 runCurrent、advanceTimeBy 或 advanceUntilIdle。官方把这一变更的理由说得很清楚:它更接近生产条件,能有效暴露竞态条件,使测试套件更稳健、更少 flaky。这反过来印证了生产环境中 effect 的时间边界:它不由你直接掌控,在测试里表现为“你必须显式驱动它”。
五、并发边界:effect 之间没有可靠的顺序契约
多个平级 LaunchedEffect 在同一主调度器上按声明顺序 launch,同步前缀按声明顺序执行到第一个挂起点,之后交错。但“同步前缀有顺序”不是官方承诺的稳定契约,而且一旦有挂起,顺序就不再保证。
LaunchedEffect(Unit) { sharedState = loadConfig() }
LaunchedEffect(Unit) { useConfig(sharedState) } // 可能读到 null
正确做法不是调整顺序,而是把有依赖的工作合并到一个 effect,或把依赖显式建模为 key 和状态。effect 应该被设计为相互独立的生命周期单元,而不是靠调用顺序维系的命令式脚本。
snapshotFlow 的下游修改 Compose 状态,可能触发新的 apply 和新的发射,形成反馈环。这是快照隔离与异步 Flow 的固有边界。让 snapshotFlow 只做观察,写操作显式节流或去重。官方文档对“状态 vs 事件”的区分在这里同样适用:状态观察者必须是幂等的,中间状态可能被跳过,同一状态可能被观察到多次;如果下游写操作不满足这个约束,反馈环就会放大语义不一致。
六、异常边界:effect 的异常不会自己变成 UI 错误
LaunchedEffect 协程的未捕获异常不会让 Compose 自动渲染错误状态。路径是:协程异常 → CoroutineExceptionHandler(如果上下文中有)→ 否则调度器的未捕获异常处理器 → Android 上通常崩溃。CoroutineExceptionHandler 只对没有传播路径的异常生效;launch 中未处理的异常被 kotlinx.coroutines 视为编程错误,会触发 last-resort 异常处理,可能直接崩溃程序。
所以 effect 的异常必须显式管理。正确策略是在 effect 的业务代码内部 try/catch 可预期异常,把错误建模为状态:
LaunchedEffect(userId) {
val result = runCatching { repository.load(userId) }
uiState = result.fold(
onSuccess = { UiState.Success(it) },
onFailure = { UiState.Error(it) }
)
}
produceState 的 producer 异常同理:协程失败,State 停在最后值,UI 可能永远加载中。onDispose 的异常更危险:它在 apply 阶段同步执行,异常会传播到组合提交过程。onDispose 应短小、不抛异常;必须处理的清理失败应在内部吞掉并记录。
effect 协程失败不会自动取消同级的其他 effect(它们是独立 launch 的),除非异常到达父 Job。不要假设“一个 effect 失败会拖垮整个屏幕”——它可能只是让对应的 UI 分支永远停在中间态。
七、测试边界:effect 是“被驱动的时钟”
MainTestClock 驱动帧、重组和 launched effects。LaunchedEffect 里的 delay 和 withFrameNanos 不会真实等待,需要 advanceTimeBy 或 advanceUntilIdle。SideEffect 在每次 apply 后执行,DisposableEffect.onDispose 在 disposeContent 或 key 变化时同步调用。
两条测试边界:不要用真实时间断言 effect,用 MainTestClock 显式推进;effect 的取消行为可以被测试——切换 key 或 dispose content,断言 onDispose 被调用、协程不再发射。在 v2 StandardTestDispatcher 下,尤其需要注意 runCurrent / advanceTimeBy / advanceUntilIdle 的显式驱动,否则协程可能停在队列中未被观察。
八、架构边界:effect 是 UI 层的生命周期适配器
前七层是技术边界。最深的一层是架构性的:effect 属于 UI 层,职责是把组合的生命周期“翻译”成对外部系统的调用时机。
官方文档的架构警告值得直接引用:effect 中的工作应该与 UI 相关,并且不破坏单向数据流。一个清晰的信号:当 LaunchedEffect 块超过十几行,开始包含条件分支、重试循环、错误分类、缓存策略或多步状态转换时,它已经越界。这些逻辑的正确归属是 ViewModel、UseCase 或 Repository——它们有独立于 UI 生命周期的测试方式,有不依赖 Compose 运行时的并发模型。
- 状态归 ViewModel/状态持有者:UI 状态通过
StateFlow或mutableStateOf向下流动,effect 不生产业务状态。 - 事件归 UI:用户交互通过回调进入
rememberCoroutineScope或转发给 ViewModel。 - 一次性动作归 effect:导航、Snackbar、analytics 事件,由
LaunchedEffect收集SharedFlow/Channel消费。 - 资源配对归
DisposableEffect:onDispose必须完整、短小、不抛异常。
四条边界守住之后,effect 的代码会变得很薄:只做“在正确的时刻调用正确的东西”,不做“决定调用什么以及如何处理结果”。薄,正是正确的信号。
架构边界可以用一张分层图收束:effect 只做“时机翻译”,不做业务决策。
九、决策框架:别问“用哪个 API”,问边界问题
一问触发源。 进入组合或状态变化 → LaunchedEffect;用户事件回调 → rememberCoroutineScope;每次成功提交后同步一次 → SideEffect。
二问是否需要清理。 注册了监听器或持有必须释放的资源 → DisposableEffect,onDispose 完整;只是启动由 Compose 管理的协程 → LaunchedEffect 已提供取消。
三问结果是状态还是事件。 可读取的当前值 → produceState 或 snapshotFlow;必须逐个消费的一次性事件 → LaunchedEffect + SharedFlow/Channel。这里的关键区分来自官方对状态与事件的建模:状态是“现在是什么”,事件是“发生过什么”;状态变化会被合并,事件必须被逐个观察。
四问生命周期跟随谁。 跟随组合位置 → LaunchedEffect/rememberCoroutineScope;跟随 ViewModel → viewModelScope;跟随进程 → 根本不应该出现在 effect 里。任何比 UI 更长寿的作用域,如果捕获了 Activity Context 或 Composable 引用,就越过了泄漏边界。
五问是否复杂到需要独立测试。 如果是,它已经越过架构边界。移出去,让 effect 只保留“调用时机”的薄壳。
把五问串起来,就是一棵可以直接照着走的选型决策树:
十、习题:15 道边界检验
1.(选择) 下列关于 LaunchedEffect(Unit) 的说法,正确的是:
A. 保证整个应用中只执行一次
B. 保证当前组合实例生命周期内只启动一次,但组合实例重建后会再次执行
C. 等价于 SideEffect,只是可以挂起
D. 每次重组都会重启
2.(判断) LaunchedEffect 的协程默认运行在 Dispatchers.IO 上,可以直接做网络请求而不阻塞主线程。
3.(代码分析) 下面代码有什么问题?
@Composable
fun SearchScreen(keyword: String) {
var results by remember { mutableStateOf<List<Item>>(emptyList()) }
LaunchedEffect(keyword) {
results = repository.search(keyword)
}
LazyColumn { items(results) { ItemRow(it) } }
}
4.(填空) LaunchedEffect 的 block 类型是 suspend ______.() -> Unit,这个 receiver 让 effect 内部启动的子协程归属于 effect 的生命周期。
5.(简答) 为什么不能在组合函数体里直接调用 viewModel.loadData()?请从“函数体执行”和“进入 Composition”的区别切入回答。
6.(选择) 用户点击按钮后发起一个 3 秒动画并弹 Toast,最适合放在:
A. LaunchedEffect(Unit)
B. SideEffect
C. rememberCoroutineScope().launch
D. DisposableEffect
7.(场景设计) 监听一个传感器,Composable 进入时注册、离开时注销,sensorId 变化时重新注册。写出合适的 effect 结构,并说明 onDispose 必须做什么。
8.(判断) “离开 Composition 时协程会自动取消”意味着只要用了 LaunchedEffect,就绝不会发生协程泄漏。
9.(代码分析) 下面 DisposableEffect 有什么隐患?
DisposableEffect(listener) {
eventBus.register(listener)
onDispose {
eventBus.unregister(currentListener)
}
}
var currentListener by remember { mutableStateOf(listener) }
10.(简答) snapshotFlow 和 SideEffect 都能“响应状态变化”,它们的边界有什么本质区别?
11.(选择) produceState(initialValue = 0, key1 = userId) 在 userId 变化时:
A. State 被重置为 0,producer 重启
B. State 保留上一次的值,producer 重启
C. State 被重置为 0,producer 不重启
D. State 保留上一次的值,producer 不重启
12.(代码分析) 下面代码想实现“连接建立后回调永远调用最新的 onMessage,但 connectionId 不变时不重连”。它正确吗?为什么?
LaunchedEffect(connectionId, onMessage) {
connect(connectionId) { msg -> onMessage(msg) }
}
13.(判断) 同一个 Composable 中两个平级的 LaunchedEffect,第一个的同步前缀一定在第二个之前执行,因此可以用第一个 effect 给第二个 effect 准备状态。
14.(场景设计) 一个页面需要在 LaunchedEffect 中加载用户数据,失败时显示错误页。写出关键代码,并说明为什么不能只依赖 CoroutineExceptionHandler。
15.(综合简答) 有人说:“既然 effect 有这么多边界,那把所有副作用都放到 ViewModel 里,Composable 里一个 effect 都不用,不就安全了?”评价这个观点,并说明 effect 在架构上不可替代的职责。
十一、参考答案与解读
1. B。 “一次”相对于当前组合实例。导航返回、分支重新进入、组合实例重建,effect 都会再次执行。它不等价于 SideEffect(同步、每次提交都跑),也不会每次重组都重启(key 不变则不重启)。
2. 错。 LaunchedEffect 的上下文在 Android 上通常包含 AndroidUiDispatcher.Main,默认在主线程恢复。直接做阻塞式网络请求会卡主线程,必须显式 withContext(Dispatchers.IO)。
3. 两层问题。 业务边界上,搜索请求、结果映射、错误处理全在 effect 里,应移到 ViewModel。正确性上,repository.search 抛异常时协程失败,results 停在旧值,UI 没有任何错误反馈;keyword 变化时旧结果也会短暂残留。正确做法是在 effect 内 runCatching 并把结果建模为 UiState,或者直接让 ViewModel 持有搜索状态。
4. CoroutineScope。 它让 effect 内部 launch 的子协程成为 effect 协程的子 Job,effect 取消时一并取消,体现“effect 内部异步工作归属于 effect 生命周期锚点”。
5. 函数体执行不等于进入 Composition。一次函数体执行可能最终被跳过、被丢弃,也可能因父级失效而重复执行。loadData() 一旦绑在函数体上,就成了“计算界面”这个求值过程的一部分,运行时有权跳过、取消、重复执行它。LaunchedEffect 保证的恰恰是“只在进入 Composition 之后才执行”。
6. C。 触发源是用户点击,不是“进入组合”或“状态变化”,走 rememberCoroutineScope。A 把事件建模成了生命周期;B 不能挂起且每次提交都跑;D 用于资源配对。
7.
DisposableEffect(sensorId) {
val listener = SensorListener { /* ... */ }
sensorManager.register(sensorId, listener)
onDispose {
sensorManager.unregister(sensorId, listener)
}
}
onDispose 必须注销本次 effect 块注册的那个 listener 实例,不能读外部可变状态“找当前 listener”,否则快速切换 sensorId 时可能注销错对象。
8. 错。 取消是协作式的。阻塞在不响应中断的调用上,或在没有挂起点的循环里空转,取消信号无法生效。LaunchedEffect 提供的是取消信号,不是强制终止。官方示例用 while (isActive) 配合 delay 正是为了提供可取消的边界。
9. 配对错位。 onDispose 注销的是 currentListener(可能已被更新为“最新值”),而 effect 块注册的是本次闭包捕获的 listener。快速变化时,onDispose 可能注销一个尚未注册的新 listener,旧 listener 留在 eventBus 上造成泄漏。正确写法是在 effect 块内用局部变量持有本次注册的实例,onDispose 只注销它。
10. 本质区别在“响应什么”。 SideEffect 响应“一次成功的组合提交”,每次 apply 后同步执行,不区分值是否变化;snapshotFlow 响应“只读快照中读取的值发生变化”,基于 equals 去重,值不变不发射,并且是异步 Flow。用 SideEffect 追踪高频状态会按提交频率触发,用 snapshotFlow 才能按值变化频率触发。更深一层,snapshotFlow 建模的是状态变化事件,下游必须按状态语义(幂等、可合并)来消费,而不是按原始事件流语义。
11. B。 produceState 内部是 remember { mutableStateOf(initialValue) } 加 LaunchedEffect(keys),remember 没有 key,所以 key 变化时 State 保留上一次的值,只有 producer 重启。官方 issue tracker 上记录了真实的图片加载和聊天会话案例:切换 URI 或房间时旧值残留,导致 UI 显示上一张图片或使用旧会话解密。要重置,需要在 producer 开头显式赋值,或用 key() 包裹。
12. 不正确。 把 onMessage 放进 key,会导致每次引用变化都取消并重建连接,违背“connectionId 不变时不重连”的意图。正确写法:
val currentOnMessage by rememberUpdatedState(onMessage)
LaunchedEffect(connectionId) {
connect(connectionId) { msg -> currentOnMessage(msg) }
}
13. 前半句在当前实现下大致成立,后半句是错的。 同步前缀有声明顺序,但一旦有挂起,顺序就不再保证,而且这个前缀顺序不是官方承诺的稳定契约。更重要的是,用第一个 effect 给第二个准备状态,本身就是把 effect 当成命令式脚本,违反了“effect 应是相互独立生命周期单元”的并发边界。有依赖的工作应合并到一个 effect,或把依赖建模为 key 和状态。
14.
var uiState by remember { mutableStateOf<UiState>(UiState.Loading) }
LaunchedEffect(userId) {
uiState = UiState.Loading
val result = runCatching { repository.loadUser(userId) }
uiState = result.fold(
onSuccess = { UiState.Success(it) },
onFailure = { UiState.Error(it) }
)
}
不能只依赖 CoroutineExceptionHandler:它只对没有传播路径的未捕获异常生效,此时协程已经失败,uiState 停在 Loading,UI 没有错误反馈;某些配置下异常直接导致崩溃。可预期异常必须在 effect 业务代码内部 try/catch(或 runCatching),显式建模为状态。
15. 方向对了一半,结论错了。 业务逻辑、错误分类、缓存策略、重试确实应归 ViewModel/Repository,effect 不该成为业务控制器。但 effect 在架构上有不可替代的职责——它是 Compose 声明世界与外部命令世界之间的唯一合法关口。官方文档明确把 effect 定位为“在可感知 composable 生命周期的受控环境中执行动作”。导航、Snackbar、一次性 analytics 事件、需要与组合生命周期严格配对的资源注册/注销,这些动作的“发生时机”必须由 Compose 的生命周期锚点决定,ViewModel 不知道组合何时进入、何时离开、key 何时变化。把这些全部推到 ViewModel,要么让 ViewModel 依赖 UI 生命周期(架构倒置),要么在 Composable 里用回调绕过 effect(回到函数体写副作用的老问题)。正确做法是:业务归 ViewModel,时机归 effect,effect 保持薄壳。
十二、本节课知识点总结
运行时层。 effect 协程上下文来自 Recomposer.effectCoroutineContext,LaunchedEffect 和 rememberCoroutineScope 都是 effectJob 的子 Job;Android 上默认由 AndroidUiDispatcher 在主线程恢复,并携带 MonotonicFrameClock;block 的 CoroutineScope receiver 让子协程归属 effect 生命周期;取消是协作式的,需要 isActive / ensureActive() / 挂起点配合;未捕获异常走协程异常传播路径,CompositionErrorContext 只附加诊断信息、不改变崩溃行为。跨平台语义一致,调度器实现因平台而异。
API 层。 LaunchedEffect 由 key 约束,表达不了进程级“只执行一次”,不适合响应回调事件,key 必须稳定且语义正确,重启成本要纳入设计。rememberCoroutineScope 用于事件驱动,不能写在函数体里承载“进入时执行”,scope 失败后无法再启动子任务。DisposableEffect 强制配对,effect 与 onDispose 在 apply 调度器上串行,onDispose 同步、短小、释放本次注册的资源、不抛异常。SideEffect 跟随每次提交,不跟随值变化。produceState 建模状态而非事件,key 变化不重置 initialValue(官方 issue 中有图片加载和加密会话的真实案例),State 合并值,中间值不保证被观察。snapshotFlow 在只读快照上运行,修改快照数据会抛 IllegalStateException,equals 决定发射语义,block 必须幂等无副作用;它建模状态变化事件,但下游必须按状态语义消费。rememberUpdatedState 解决长 effect 读取短依赖的闭包捕获问题。
时间层。 取消需要代码配合;key 变化的重启成本必须纳入设计;清理与注册严格配对,一个资源一个所有者。测试中 MainTestClock 显式驱动;Compose 1.11.0 起 v2 StandardTestDispatcher 成为默认,协程进入队列,需要 runCurrent / advanceTimeBy / advanceUntilIdle 显式推进。
并发层。 effect 之间没有可靠的顺序契约,有依赖的工作应合并或建模为 key/状态;snapshotFlow 下游写操作可能形成反馈环,需要节流或去重,并且下游必须满足状态观察者的幂等性要求。
异常层。 可预期异常在 effect 业务代码内部捕获并建模为状态;CoroutineExceptionHandler 是安全网不是错误处理机制;onDispose 异常可能破坏组合提交;effect 失败不会自动取消同级 effect。
测试层。 effect 由 MainTestClock 驱动,delay 和帧回调不会真实等待;取消行为和 onDispose 调用可以被逐条断言;调度器迁移后必须显式推进队列。
架构层。 状态归 ViewModel,事件归 UI,一次性动作归 effect,资源配对归 DisposableEffect。官方警告 effect 容易过度使用,effect 中的工作应与 UI 相关且不破坏单向数据流。effect 的代码应该薄,只负责“在正确的时刻调用正确的东西”。
一句话收束: 每一个 effect 都是一份契约,契约的核心不是授予能力,而是限定范围。LaunchedEffect 停在业务逻辑之前,rememberCoroutineScope 停在组合体之外,DisposableEffect 停在有清理之后,SideEffect 停在每次提交的语义之内,produceState 停在状态而非事件,snapshotFlow 停在观察而非同步。知道在哪儿停下来,才算真的会了。
结语
Effect API 的学习曲线有一个独特的形状。入门时你学“用哪个 API 做副作用”;中级时你学“哪个 API 对应哪个生命周期”;到了深水区,真正区分水平的,不是“知道多少种用法”,而是知道每一种用法在哪里必须停下来。
Compose 的声明式模型之所以强,是因为它把“什么时候做”从开发者手中拿走,交给了运行时。Effect API 是你和运行时重新谈判的接口。谈判边界越清晰,代码越可预测;边界越模糊,effect 就越容易变成藏竞态、藏泄漏、藏重复执行的灰色地带。
在 effect 的世界里,克制不是风格,是正确性。
下期预告
第5课:组合身份与作用域的边界——key、movableContentOf 与 CompositionLocal 的深水区
本课反复出现一个词:组合身份。effect 的“离开/进入组合”判定依据的不是 UI 位置,而是组合身份。key() 改变时旧子树的 effect 被取消、新子树重建;movableContentOf 移动 content 时将已记住的状态和节点一起移动,组合身份保持不变、effect 不重启。
下一课拆这层锚点:key 到底改变了什么,为什么它能“重置”一个子树;movableContentOf 如何在移动中保持状态和 effect;CompositionLocal 的传播边界在哪里——staticCompositionLocalOf 的读取不被 composer 追踪,值变化会无效化整个提供范围,因此只适合“极不可能或永远不会变化”的值;compositionLocalOf 则追踪读取,只让实际消费者重组。以及“作用域”在 Compose 里到底指什么——重组作用域、快照作用域,还是组合身份划出的生命周期作用域。
第3课的 remember 回答“值存在哪儿”,第4课的 effect 回答“动作拴在哪儿”,第5课要回答的是:这个“哪儿”本身是怎么被定义的。 下期见。