摘要
第2课解决了稳定性“怎么推断、怎么证明”。但稳定性只回答“参数能不能比较后跳过”,不回答“这个值能在组合里活多久”。remember看起来是“把值存起来”,实际边界由三层机制共同划定:位置记忆的脆弱性、key 的身份语义、保存与重建的层级差异。本文从“返回再进入,输入框内容没了”切入,拆解remember的源码行为(changed的非短路or、SlotTable 锚点如何让位置在结构变动后存活)、三类真失效与一种误判、rememberSaveable的保存链路与“消费即清除”、rememberUpdatedState如何以一行源码解耦 effect 存活与值更新、derivedStateOf的频率硬判据,以及movableContentOf作为位置身份迁移的专门工具。核心原则延续第2课:remember 不是缓存开关,是组合生命周期上的一份位置合同;key 不是刷新按钮,是身份声明。
版本提醒:Strong Skipping 自 Kotlin 2.0.20 起默认启用,lambda 的记忆化行为随之变化;SlotTable 内部实现持续演进,具体以项目所用 Compose Runtime 版本为准。
目录
- 一、开场:修好了卡顿,却把用户输入弄丢了
- 二、remember 记住了什么:位置作为隐式参数
- 三、三类真失效与一种误判
- 四、key 的边界:身份声明,不是刷新按钮
- 五、rememberSaveable:保存链路、Bundle 边界与 Saver 合同
- 六、rememberUpdatedState:一行源码,稳定引用 + 最新内容
- 七、remember 与 derivedStateOf:频率硬判据
- 八、movableContentOf:位置身份可以“搬”,而不是“重建”
- 九、Strong Skipping 之后:lambda 不再每轮新建
- 十、完整案例追踪:从输入丢失到正确修复
- 十一、选型决策
- 十二、15 道多元化习题(含参考答案与解读)
- 十三、本节课知识点总结
- 十四、通向第 4 课(预告)
一、开场:修好了卡顿,却把用户输入弄丢了
你写了一个搜索页,输入框内容用 remember 保存。用户输入“Compose”,点击结果进入详情页,再返回——输入框空了。
第一反应是“remember 失效了”。更准确的说法是:返回时进入的是一次新的组合,搜索页回到了默认值。 remember 没有“忘记”什么;它从一开始就没有承诺跨越导航出栈后的重组保留状态。
另一个变体更隐蔽:列表 item 内部用 remember 保存展开状态,LazyColumn 没有稳定 key。插入一条数据后,后续 item 状态错位。这不是 remember 的 bug,而是位置身份被重用了——Compose 认为某个位置仍然是“同一个节点”,把上一个 item 的 remember 记录交给了新 item。
remember 的边界问题从来不是“它能不能记住”。真正的问题是:它在什么身份下记住、记住的值放在哪里、什么时候会被判定为“另一个身份”而重建、以及重建后有没有人能把值还回来。
二、remember 记住了什么:位置作为隐式参数
1. 源码路径:cache 与 changed
remember 的编译器产物最终落到 Composer.cache。不带 key 的版本传入 false,表示“永不被 key 无效化”:
@Composable inline fun <T> remember(calculation: @DisallowComposableCalls () -> T): T =
currentComposer.cache(false, calculation)
带 key 的版本先对每个 key 调用 currentComposer.changed(key),再把结果交给 cache:
@Composable inline fun <T> remember(key1: Any?, calculation: ...): T {
return currentComposer.cache(currentComposer.changed(key1), calculation)
}
changed(key) 读取 SlotTable 中下一个 key 槽位并与传入值比较;cache(invalid, calculation) 在 invalid 为 true 时丢弃旧槽位、执行 calculation,否则返回旧值。
2. 为什么是 or,不是 ||
多 key 版本把 changed 的结果用 or 串起来:
return currentComposer.cache(
currentComposer.changed(key1) or currentComposer.changed(key2),
calculation
)
or 不是风格选择。 每次 changed() 都会从 SlotTable 读取一个槽位并把读游标向前推进。如果用 || 且第一个 changed 返回 true,第二个 changed 会被短路,游标不会越过第二个 key 的槽位,后续所有槽位读取都会错位。非短路的 or 保证每个 changed() 都执行,游标始终同步。这是 remember 位置记忆在实现层面的一条硬约束,也是理解“为什么 key 的读取顺序必须与写入顺序一致”的底层原因。
3. 锚点:位置在结构变动后仍然存活
如果 SlotTable 只是一棵静态树,“按位置检索”在结构增删时会立刻崩溃。让位置记忆在变动后仍然成立的是锚点(Anchor)。
SlotTable 源码注释写得很直接:锚点会随内容插入和移除而更新;即使 item 在 SlotTable 中被移动,锚点仍然报告该 item 的位置;如果锚点引用的位置被移除,锚点位置被置为 -1。重组边界正是依靠锚点,在失效发生时精确恢复遍历位置,而不是扫描整棵树。
这解释了原稿只说了“按位置检索”但没讲透的一件事:位置身份之所以能在结构变动中存活,不是因为“位置编号”固定不变,而是因为锚点在变动后被修复了。 当一个 group 被永久移除时,锚点失效,对应的 remember 槽位随之释放——“离开组合”在底层的样子就是锚点失效。
4. 合同的三条边界
在同一次组合的同一个位置上,
remember返回同一个值;当位置离开组合,或位置身份被判定为另一个节点,值被丢弃;下次进入时重新执行初始化。
- 时间边界:值只活到离开组合为止。
- 身份边界:位置身份变了,值就重置。
- 持久化边界:组合被配置变更或进程重建打断,
remember默认不负责把值带回来。
三条边界可以用一张图概括:
三、三类真失效与一种误判
1. 离开组合
if (show) { MyComposable() } 中 show 变为 false,子 group 被移除,锚点失效,remember 槽位释放;导航出栈、列表回收同理。这不是 bug,是设计边界。值必须在离开组合后仍然存在时,它就不应该只由 remember 保管。
2. 位置身份变化
显式 key:key(userId) { ProfileEditor() } 中 userId 变化,子树被判定为新节点,内部 remember 全部重置。
隐式结构变化:同一父级下增删 sibling、改变分支结构,可能导致 group 的锚点被重新解释,remember 所在位置的槽位不再匹配。把 remember 放在稳定的结构层级上,比依赖条件分支中的位置更安全。
3. 配置变更与进程重建
remember 的槽位在组合离开时已经释放,重建时重新初始化。跨配置变更需要 rememberSaveable;跨进程重建还需要保存链路能进入 SavedStateRegistry / Bundle。注意:配置变更和进程重建共用同一条 registry → savedInstanceState 路径,但恢复时机不同——进程重建后 SavedStateRegistry 的恢复更晚,上游数据源可能尚未就绪。rememberSaveable 不区分二者,但业务层必须区分。
4. 一种误判:上游覆盖
状态实际上是“上层下发 + 事件回调”模式,子组件内部没有持有权。上层把参数重新设置为默认值,子组件表现为“回到默认”。排查时先问:这个值真的由当前 remember 持有,还是它只是一个被父级参数覆盖的镜像?
三类真失效与一种误判的关系如下:
四、key 的边界:身份声明,不是刷新按钮
remember(key) 的语义是:key 与上一次组合中的对应值不相等时,丢弃旧槽位、重新执行 calculation。它声明的是身份,不是内容。key 变化意味着“这个位置被判定为一个新的记忆身份”。
列表场景中,remember(list.size) 不可靠:内容原地修改而 size 不变时不重建;换新对象但 size 恰好相同时也不重建。列表 key 应该是元素的稳定标识(如 id)。LazyColumn 中 items(list, key = { it.id }) 让 item 内部的 remember 跟随元素,而不是跟随位置。
rememberSaveable 的手动字符串 key 已被弃用,原因比“位置语义相悖”更具体:传入非空 key 时,currentCompositeKeyHash 完全不被使用,保存 key 由手写字符串直接指定,这个 key 实际上成为 LocalSaveableStateRegistry 范围内的全局值;在时间分离的场景下,不同位置的 rememberSaveable 可能共享状态,嵌套 LazyLayout 中的状态丢失或意外共享是典型症状。正确方向是使用位置哈希,用 inputs 控制重置。
五、rememberSaveable:保存链路、Bundle 边界与 Saver 合同
1. performSave 与 consumeRestored:消费即清除
rememberSaveable 底层是 SaveableStateRegistry:
registerProvider(key, valueProvider)注册值提供者;同一个 key 允许多个 provider,保存时按注册顺序形成列表。performSave()执行所有 provider,合并成Map<String, List<Any?>>;同一 key 下按注册顺序排列。consumeRestored(key)返回恢复值,但值一旦被消费就被清除,同一个 key 不能恢复两次;同一 key 有多个值时,按顺序依次消费。
这条“消费即清除”语义是理解保存边界的关键:恢复不是“把值放回去等下次再用”,而是一次性消费。 如果消费发生在错误的组合轮次,值就没了。这也解释了为什么 rememberSaveable 的恢复要求时机正确,以及为什么嵌套懒布局中的保存/恢复时序可能不足以稳定标识状态。
保存与恢复的完整链路可以这样理解:
2. Bundle 边界与 autoSaver
值类型可以直接放入 Bundle 时走 autoSaver;否则必须提供自定义 Saver。String、基本类型、Parcelable、Serializable 在边界内;大对象图、临时 UI 状态、与页面强绑定的交互状态不应硬塞。
3. Saver 只做编解码
Saver 的合同只有 save 和 restore。save 返回 null 表示当前不值得保存。它不负责校验恢复值与当前 inputs 是否匹配——文档明确说明状态恢复不会根据保存前提供的 inputs 做校验。inputs 的作用是“变化时重置并重新执行 init”,不是“保存时绑定身份”。listSaver / mapSaver 约束保存表示的形态,减少 List<Any> 强转的类型风险。
4. 嵌套 LazyLayout 的缺口与 movableContentOf
嵌套懒布局中,rememberSaveable 可能在滚动回收时丢失状态,尤其是在 LazyColumn 内嵌 LazyRow 的场景。这不是单纯的“位置哈希不够”,而是保存/恢复时序与位置身份在嵌套回收中不完全对齐。movableContentOf 提供了一条互补路径:把状态和节点随内容“搬”到新位置,而不是按位置重建(见第八节)。
六、rememberUpdatedState:一行源码,稳定引用 + 最新内容
rememberUpdatedState 的全部实现是一行:
inline fun <T> rememberUpdatedState(newValue: T): State<T> =
remember { mutableStateOf(newValue) }.apply { value = newValue }
remember 保证 State 对象引用在重组间稳定;.apply { value = newValue } 在每次调用重组时把内部值更新为最新。效果是:effect 不重启(引用稳定),但 effect 读取到的值是最新的(内容更新)。
官方文档的措辞精确对应这一机制:当长期存在的 lambda 或对象表达式引用组合期间计算的参数或值时使用它;它更新状态而不重建长期对象,使对象持续存在而不必取消和重新订阅,或重新启动代价高昂的长时操作。
它与 key 重启的分工:
- 值放进 key:值变 → effect 重启 → 旧工作取消,新工作开始。适合“值的变化意味着 effect 本身应重新建立”的场景。
rememberUpdatedState:值变 → effect 不重启 → 内部读到最新值。适合“effect 应持续存活,但需要访问最新参数”的场景。
判据:effect 内部的工作在值变化时应被取消并从头开始 → 用 key;effect 描述的是一个不应被打断的状态机,只是需要当前值 → 用 rememberUpdatedState。 注意它的值在 remember { } 块内部是“旧的”;它的用途是给 long-lived effect 读取,不是给 remember 的初始化 lambda 提供动态输入。
七、remember 与 derivedStateOf:频率硬判据
derivedStateOf 产生一个 State,其读取方只在派生结果变化时失效,即使输入状态变化得更频繁。
判据可以收紧为一条硬条件:输入频率必须严格超过输出频率。 输入频率等于输出频率时,derivedStateOf 是纯开销——多了一次快照订阅,没有任何过滤收益。例如 "$first $last" 从两个名字状态拼接,输入和输出同步变化,不应使用 derivedStateOf;滚动位置驱动布尔阈值则是典型适用场景。
它必须配合 remember 使用;缓存的是派生结果,不是任意计算。它也不解决相位问题:如果状态读取发生在错误的阶段,应该先做相位延迟,而不是用 derivedStateOf 掩盖。
常见捕获陷阱:derivedStateOf 的 lambda 捕获了非 State 的普通变量,该变量只在首次组合时求值,派生结果永远停留在初始值。修复是用 remember(key) 在 key 变化时重建 derivedStateOf,或确保 lambda 内读取的是 State 对象。
八、movableContentOf:位置身份可以“搬”,而不是“重建”
movableContentOf 把 composable lambda 转换成“将上次调用中记住的状态和节点移动到新调用位置”的 lambda。当前一次调用离开组合时状态被暂时保留;新调用进入组合时,状态和节点被迁移到新位置;如果不再有新的调用,状态被完全删除并通知观察者。
它与 remember 的位置合同形成互补:
remember的身份绑定在位置上;位置变了,值重置。movableContentOf允许把状态和节点随内容一起搬到新位置;内容出现在新位置时,状态跟随内容,而不是按新位置重建。
典型场景:同一份内容在 Row 和 Column 之间切换、列表 item 换位、面板在不同容器间迁移。官方设计文档指出,movableContentOf 可以用于“key 用起来别扭或容易导致状态丢失”的地方。
边界:它解决的是移动,不是离开。如果内容被永久移除(不再在任何位置调用),状态仍然会被永久删除。movableContentOf 不是“让所有状态永不丢失”的银弹。
九、Strong Skipping 之后:lambda 不再每轮新建
Kotlin 2.0.20 起 Strong Skipping 默认启用。它有两个直接影响第3课的行为:
- 所有可重启 composable 变为可跳过,无论参数是否稳定;不稳定参数改用
===比较,稳定参数仍用equals()。 - 带不稳定捕获的 lambda 被自动
remember:编译器用remember包裹 lambda,以捕获作为 key。此前每次重组创建新 lambda 实例,===永远失败;现在捕获不变则引用稳定。
这对 remember 边界的影响是:lambda 实例的“是否每轮重建”不再完全由手写代码决定。如果你依赖“每次重组拿到新 lambda”的行为,Strong Skipping 可能改变它;如果你依赖“lambda 引用稳定来帮助跳过”,它可能自动帮你做到。审查代码时,不能再用“lambda 反正每轮新建”作为不 remember 的默认理由。
十、完整案例追踪:从输入丢失到正确修复
回到开场的搜索页。
定位。 query 由 remember 持有;导航出栈再入栈,remember 槽位释放。如果旋转屏幕也丢失,说明持久化层级不够。
修复选择。
- 只需跨配置变更 →
rememberSaveable { mutableStateOf("") },String在 Bundle 边界内。 - 需要跨导航出栈 →
rememberSaveable不够,提升到ViewModel(跨配置变更和导航生命周期)或SavedStateHandle(跨进程重建、小体积可序列化)。 - 列表 item 错位 → 给
items提供稳定 key;嵌套懒布局保存不稳时,考虑movableContentOf。
验证。 旋转屏幕、导航返回、列表插入删除三种场景分别验证;不要把“导航返回不保留”误判为 bug,rememberSaveable 本来就不覆盖它。
十一、选型决策
| 需求 | 选择 | 边界 |
|---|---|---|
| 只在当前组合内保留,离开即丢 | remember | 位置记忆;锚点失效即释放 |
| 跨配置变更,小体积可保存状态 | rememberSaveable | Bundle 内或有 Saver;不跨导航出栈;恢复是消费即清除 |
| 跨导航、业务逻辑、较大状态 | ViewModel | 跨配置变更,不独自应对进程死亡 |
| 跨进程重建、小体积可序列化临时状态 | SavedStateHandle | 轻量草稿;需要序列化 |
| effect 不重启但需最新值 | rememberUpdatedState | 不替代 key 重启;不穿透 remember 初始化 |
| 输入频率严格大于输出频率的派生条件 | remember { derivedStateOf { } } | 频率相等时是纯开销;不解决相位问题 |
| 内容需要在不同容器间迁移而保留状态 | movableContentOf | 解决“移动”,不解决“永久移除” |
选型可以按“值需要活多久”逐层判断:
十二、15 道多元化习题(含参考答案与解读)
题型覆盖:判断题、单选题、多选题、代码找错、代码改错、场景匹配、执行顺序推理、综合设计。
习题 1(判断): remember 按变量名检索缓存值。
参考答案: 错误。remember 按调用树中的执行位置检索,底层是 SlotTable 槽位和锚点;同名变量不干扰是因为位置不同。
解读: 理解位置身份是理解后续所有失效场景的地基。
习题 2(判断): rememberSaveable 能保证值在进程死亡后一定恢复。
参考答案: 错误。它只保证“可进入 Bundle 或提供 Saver 的值”通过 saved instance state 存活;不保证 SavedStateRegistry 可用、恢复时上游已就绪、业务逻辑不覆盖恢复值。恢复还是消费即清除,同一个 key 只能消费一次。
解读: “能保存”和“一定恢复”是两回事。
习题 3(判断): rememberUpdatedState 可以替代把值放进 effect 的 key。
参考答案: 错误。key 让 effect 重启、旧工作取消;rememberUpdatedState 让 effect 不重启但读到最新值。业务要求“值变时旧工作必须取消并从头开始”时,它不能替代 key。
解读: 源码是 remember { mutableStateOf(newValue) }.apply { value = newValue }:保鲜,不重启。
习题 4(单选): 下列哪种情况不会导致 remember 重置?
A. 条件渲染离开组合
B. remember(key) 的 key 与上次不等
C. LazyColumn item 被回收且无稳定 key
D. 父级重组,子级仍在组合中、位置未变、key 未变
参考答案: D。父级重组本身不重置子级 remember;只要锚点仍指向同一个 group、key 未变,值就保持。
解读: 失效条件是具体的,不是“上层动了就重置”。
习题 5(单选): 关于 rememberSaveable 的手动字符串 key,下列说法正确的是?
A. 它是控制身份的唯一正确方式
B. 它绕过 currentCompositeKeyHash,使 key 成为 LocalSaveableStateRegistry 范围内的全局值,因此被弃用
C. 它只在跨进程重建时生效
D. 它与 inputs 完全等价
参考答案: B。传非空 key 时 currentCompositeKeyHash 完全不被使用,保存 key 由手写字符串直接指定;时间分离时可能跨位置共享状态,嵌套 LazyLayout 中的状态丢失/意外共享是典型症状。
解读: 正确方向是位置哈希 + inputs 控制重置。
习题 6(多选): 哪些场景属于“持久化边界不够”,需要升级持有者?
A. 旋转屏幕后输入丢失
B. 导航返回后草稿丢失
C. 列表插入后 item 展开状态错位
D. 进程回收重建后草稿需要恢复
参考答案: A、B、D。C 不是持久化问题,而是位置身份问题,应通过稳定 key 修复;给 C 换 rememberSaveable 只会把错位状态也保存下来。
解读: 区分“持久化边界”和“身份边界”。
习题 7(多选): 关于 remember(key) 与 derivedStateOf,正确的有?
A. 前者在 key 变化时重新执行 calculation
B. 后者必须配合 remember 使用
C. 后者在输入频率等于输出频率时是纯开销
D. 两者可以互相替代
参考答案: A、B、C。D 错误:derivedStateOf 的硬判据是输入频率严格大于输出频率,相等时只增加快照订阅,没有过滤收益。
解读: 选型取决于频率结构,不取决于代码风格。
习题 8(代码找错): 指出下面代码的问题。
LazyColumn {
items(users.size) { index ->
var expanded by remember { mutableStateOf(false) }
UserRow(users[index], expanded, { expanded = !expanded })
}
}
参考答案: ① items(users.size) 没有稳定 key,列表变动后 item 内部 remember 按位置错位;② remember 跟随索引位置而非元素身份;③ users[index] 在列表变化时可能越界或取错元素。
解读: 修复是给 items 稳定 key,不是换 rememberSaveable。
习题 9(代码找错): 指出 stale closure 并修复。
LaunchedEffect(Unit) {
while (true) {
delay(1000)
if (events.isNotEmpty()) onEvent(events.removeAt(0))
}
}
参考答案: LaunchedEffect(Unit) 不重启,闭包捕获第一次组合的 onEvent。用 rememberUpdatedState 保鲜:val current by rememberUpdatedState(onEvent),循环内调用 current(...)。
解读: 如果业务要求回调变化时取消循环并重新开始,应把 onEvent 放进 key,而不是用 rememberUpdatedState。
习题 10(代码改错): 旋转屏幕后输入丢失,给出最小修复;如果还要求导航返回后草稿仍在,如何进一步修改?
参考答案: 最小修复:rememberSaveable { mutableStateOf("") }。导航返回仍保留:rememberSaveable 不跨导航出栈,提升到 ViewModel 或 SavedStateHandle。
解读: 关键不是写出代码,而是说明每一层修复覆盖哪种重建、不覆盖哪种。
习题 11(代码改错): 指出 Saver 的问题。
val DraftSaver = Saver<Draft, List<Any>>(
save = { listOf(it.title, it.body, it.lastEdited) },
restore = { Draft(it[0] as String, it[1] as String, it[2] as Long) }
)
参考答案: List<Any> 作为保存表示类型边界不清晰,元素类型依赖运行时,强转缺乏类型安全。更稳妥的是 listSaver / mapSaver,或明确的 Parcelable / Serializable 表示。Saver 只做编解码,不做业务一致性校验;save 返回 null 表示不保存。
解读: 考的是编解码合同,不是“能不能编译”。
习题 12(场景匹配): 匹配需求与持有者。
① 草稿只跨旋转 → rememberSaveable
② item 展开状态跟随元素移动 → remember + items(key = { it.id })
③ 小体积可序列化草稿跨进程 → SavedStateHandle
④ 较大业务状态跨导航 → ViewModel
⑤ effect 存活但读最新回调 → rememberUpdatedState
⑥ 滚动高频、下游只关心“是否显示 FAB” → remember { derivedStateOf { } }
参考答案: 如上。
解读: ② 容易误选 rememberSaveable;错位根因是位置身份,不是持久化层级。
习题 13(执行顺序推理): 当 userId 从 "A" 变为 "B",key(userId) { ProfileEditor(userId) } 内部的 remember 和 LaunchedEffect(userId) 分别怎样?
参考答案: ① 外层 key 身份变化,ProfileEditor 被视为新节点,内部 remember 槽位释放并重新初始化;② LaunchedEffect(userId) 的 key 变化,旧协程取消、新协程启动;③ 即使没有外层 key,LaunchedEffect(userId) 也会重启,但 remember { mutableStateOf("") } 不会因 userId 变化而重置——外层 key 让整个子树随用户身份干净重建。
解读: 区分两层身份:外层 key 重置整棵子树;effect 的 key 只重启自己的协程。
习题 14(综合设计): 设计“评论输入框”状态方案:旋转保留、导航返回保留、进程回收尽量恢复、草稿很小(一段文本 + 回复目标 id)。
参考答案: 输入内容放入 ViewModel 的 mutableStateOf(跨配置变更和导航);跨进程用 SavedStateHandle 保存文本和 replyToId(小体积可序列化);UI 直接读写 ViewModel,不用局部 remember 持有草稿。rememberSaveable 单独不够,因为它不跨导航出栈。
解读: 需求同时包含导航出栈和进程重建,ViewModel + SavedStateHandle 是边界内的组合。大型富文本或二进制附件不应硬塞 SavedStateHandle。
习题 15(综合设计): 从 remember 边界、key 身份、effect 保鲜、持久化层级四个角度,指出下面代码的至少四个问题。
@Composable
fun SearchScreen(onResultClick: (Result) -> Unit) {
var query by remember { mutableStateOf("") }
var results by remember { mutableStateOf<List<Result>>(emptyList()) }
LaunchedEffect(Unit) {
snapshotFlow { query }.debounce(300).collect { results = search(it) }
}
Column {
OutlinedTextField(value = query, onValueChange = { query = it })
LazyColumn {
items(results.size) { index ->
var selected by remember { mutableStateOf(false) }
ResultRow(results[index], selected, {
selected = !selected
onResultClick(results[index])
})
}
}
}
}
参考答案: ① query 持久化层级不够,需要跨配置变更或导航时升级到 rememberSaveable 或 ViewModel;② items(results.size) 没有稳定 key,selected 按位置错位,改为 items(results, key = { it.id });③ 异步搜索结果可能乱序覆盖,search(q) 返回顺序不确定时旧查询可能覆盖新查询,用 collectLatest 或移入 ViewModel 并用 flatMapLatest;④ selected 放在 item 内部且无 key 保护,同时用索引访问,结果变化时可能对应错误结果,外提为 Set<ResultId> 或至少提供稳定 key;⑤ onResultClick 闭包每次重组重建,若 ResultRow 依赖引用相等跳过可能无法跳过,用 rememberUpdatedState 保鲜或确保比较策略匹配。
解读: 第③点的微妙之处:snapshotFlow 本身观察 query,LaunchedEffect(Unit) 不重启不一定是 bug;真正的风险是并发搜索乱序,属于 effect 内部异步取消合同,第4课展开。
十三、本节课知识点总结
1. remember 的源码事实
- 无 key 版本:
cache(false, calculation),永不被 key 无效化。 - 多 key 版本:
changed(key1) or changed(key2),or非短路保证每个changed()都推进游标,否则后续槽位读取错位。 - 锚点在内容插入/移除/移动时被修复;锚点引用的位置被移除时置为
-1,槽位释放。
2. 三类真失效 + 一种误判
| 类型 | 机制 | 对策 |
|---|---|---|
| 离开组合 | 锚点失效,槽位释放 | 外提或升级持久化 |
| 位置身份变化 | key 或结构变化导致 group 重新解释 | 确认 key 表达的是身份 |
| 配置变更/进程重建 | 共用保存链路,恢复时机不同 | rememberSaveable / ViewModel / SavedStateHandle |
| 误判:上游覆盖 | 不是 remember 失效 | 检查状态提升与数据流 |
3. rememberSaveable 的保存链路
performSave合并所有 provider 为Map<String, List<Any?>>;同一 key 多值按注册顺序排列。consumeRestored消费即清除,同一个 key 不能恢复两次。- 手动字符串 key 已弃用:绕过位置哈希,成为注册表范围内的全局 key,嵌套
LazyLayout状态丢失/共享是典型症状。 Saver只做编解码;inputs不参与恢复校验。
4. rememberUpdatedState
- 源码:
remember { mutableStateOf(newValue) }.apply { value = newValue },引用稳定、内容最新。 - 不替代 key 重启:该取消重建的工作仍然用 key。
- 不穿透
remember { }的初始化捕获。
5. derivedStateOf 的硬判据
- 输入频率必须严格大于输出频率;相等时是纯开销。
- 必须配合
remember;不解决相位问题。 - 捕获非
State普通变量的陷阱用remember(key)修复。
6. movableContentOf 的边界
- 把状态和节点随内容搬到新位置,解决“移动”。
- 不解决“永久移除”:不再有调用时状态仍被删除。
- 适用于 key 用起来别扭或容易导致状态丢失的迁移场景。
7. Strong Skipping 的影响
- Kotlin 2.0.20 起默认启用;所有可重启 composable 可跳过。
- 不稳定参数用
===,稳定参数用equals()。 - 带不稳定捕获的 lambda 被自动
remember,捕获不变则引用稳定;不能再用“lambda 反正每轮新建”作为不remember的默认理由。
8. 代码审查三问
- 这个
remember的位置身份稳定吗? 是否在条件分支或缺少 key 的列表中? - 这个值离开组合后应该存在吗? 持久化层级够吗?恢复链路能消费到值吗?
- 这个 effect 需要重启还是只需要最新值? 前者 key,后者
rememberUpdatedState;派生条件先看频率是否严格超过。
十四、通向第 4 课(预告)
第3课划清了 remember 的三条边界:位置记忆的边界、key 身份的边界、保存与重建的边界。你现在能判断一个值“该不该由 remember 持有、该由哪一层持有、以及 effect 里的旧值该用 key 重启还是用 rememberUpdatedState 保鲜”。
但 remember 只解决了“值在组合里的存在性”。还有一个问题没有展开:当值的变化需要触发组合之外的副作用时,effect 的生命周期边界在哪里?
第4课要回答:
LaunchedEffect的协程在什么时候取消?key 变化时旧协程的取消与新协程的启动顺序是什么?DisposableEffect的onDispose在什么时机执行?漏掉清理会发生什么?SideEffect为什么每次成功组合后都运行?它和LaunchedEffect(Unit)的边界有什么不同?- effect 的 key 和
remember的 key 是同一套身份语义吗?为什么LaunchedEffect(Unit)在导航返回后可能再次执行? produceState、snapshotFlow、rememberCoroutineScope分别适合什么场景?它们的生命周期由谁约束?
第3课给了你“值活多久”的边界感,第4课开始处理“副作用活多久”的合同。