【探秘 Jetpack Compose 框架深水区】第3课 remember 的边界在哪里?

22 阅读26分钟

摘要
第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 保存。用户输入“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 返回同一个值;当位置离开组合,或位置身份被判定为另一个节点,值被丢弃;下次进入时重新执行初始化。

  1. 时间边界:值只活到离开组合为止。
  2. 身份边界:位置身份变了,值就重置。
  3. 持久化边界:组合被配置变更或进程重建打断,remember 默认不负责把值带回来。

三条边界可以用一张图概括:

mermaid diagram

三、三类真失效与一种误判

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 持有,还是它只是一个被父级参数覆盖的镜像?

三类真失效与一种误判的关系如下:

mermaid diagram

四、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 的恢复要求时机正确,以及为什么嵌套懒布局中的保存/恢复时序可能不足以稳定标识状态。

保存与恢复的完整链路可以这样理解:

mermaid diagram

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课的行为:

  1. 所有可重启 composable 变为可跳过,无论参数是否稳定;不稳定参数改用 === 比较,稳定参数仍用 equals()。
  2. 带不稳定捕获的 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位置记忆;锚点失效即释放
跨配置变更,小体积可保存状态rememberSaveableBundle 内或有 Saver;不跨导航出栈;恢复是消费即清除
跨导航、业务逻辑、较大状态ViewModel跨配置变更,不独自应对进程死亡
跨进程重建、小体积可序列化临时状态SavedStateHandle轻量草稿;需要序列化
effect 不重启但需最新值rememberUpdatedState不替代 key 重启;不穿透 remember 初始化
输入频率严格大于输出频率的派生条件remember { derivedStateOf { } }频率相等时是纯开销;不解决相位问题
内容需要在不同容器间迁移而保留状态movableContentOf解决“移动”,不解决“永久移除”

选型可以按“值需要活多久”逐层判断:

mermaid diagram

十二、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. 代码审查三问

  1. 这个 remember 的位置身份稳定吗? 是否在条件分支或缺少 key 的列表中?
  2. 这个值离开组合后应该存在吗? 持久化层级够吗?恢复链路能消费到值吗?
  3. 这个 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课开始处理“副作用活多久”的合同。