【探秘 Jetpack Compose 框架深水区】第1课 重组:从“会写”到“写对”的分水岭

31 阅读19分钟

摘要:本课是「探秘 Jetpack Compose 框架深水区」系列的第一课,目标不是教你新 API,而是重建一套能推理的心智模型。全文围绕四条主线展开:阶段——Compose 画一帧分组合、布局、绘制三道工序,重组只是第一道工序被重新执行;跳过——参数稳定时运行时用 equals() 比较、不稳定时用 === 比较,强跳过模式放宽了连坐规则却没有改变「新实例导致引用变化」这一事实;身份——默认按位置判定身份,动态列表必须用业务唯一标识作 key,否则 remember 状态会错位;副作用——生命周期跟随组合而非重组次数,长期存活的 effect 需用 rememberUpdatedState 解耦「存活」与「更新」。在此基础上,本课给出五类高频反模式、一套代码审查五问框架,以及 15 道配套习题,帮助你把「会写」升级为「写对」。

目录


本课定位

这是“探秘 Jetpack Compose 框架深水区”系列 20 课的第一课。它的位置比较特殊:不是教你一个新的 API,而是拆掉一个你可能一直带着的错误心智模型,换上一个能推理的模型。

前置假设:你已经能用 Compose 写出可运行的界面——Column、Row、LazyColumn、@Composable、remember、mutableStateOf 都会用。你不需要我解释“什么是可组合函数”。

学完本课,你应该能做到三件事:

  1. 看到一段 Compose 代码,能判断状态变化会触发哪个阶段重新执行;
  2. 看到“重组次数多”的现象,能沿着参数稳定性 → 跳过比较协议这条链推理根因,而不是挨个试网上说的注解;
  3. 在代码审查中,用一套五问框架识别阶段、跳过、身份、副作用四类问题。

本课不覆盖的内容:@Stable / @Immutable 的完整契约细节(第 2 课)、remember 的边界与 rememberUpdatedState 的完整模式(第 3 课)、派生状态的选择判据(第 4 课)、副作用工具箱的全景(第 5 课)。本课只建立公共地基,后续课程在这块地基上盖楼。


开场:一个你可能遇到过的下午

想象这样一个下午。你写的 Compose 页面已经能跑起来了,列表能滚动,按钮能点击,状态能更新,一切看起来都挺正常。然后产品经理走过来说:“这个列表滚动的时候有点卡,你优化一下。”

你打开 Layout Inspector,看到某个列表项在一次滚动里重组了几十次。你有点困惑:我明明没有改它的状态,它为什么一直在重组?你在网上搜了一圈,看到有人说“要用 remember”,有人说“要加 @Stable”,有人说“要用 key”,有人说“强跳过模式已经解决了这个问题”。你把能加的注解都加上了,重组次数确实降了一点,但你不确定自己是真的修好了,还是只是碰巧让它看起来好了一点。

这个下午的核心问题,不是你不懂某个 API。remember 你会用,key 你会传,@Stable 你也知道往哪儿加。真正的问题是:你对“一次重组为什么会发生”没有一个能推理的心智模型。 你所有的优化都是试出来的,而不是想出来的。

这一课要做的,就是把那个心智模型建起来。建好之后,你面对任何一个 Compose 性能问题,都能从“它为什么重组”开始推理,而不是从“网上说加什么”开始试。

我们慢慢来。先从最基础的问题开始:Compose 到底是怎么把界面画出来的?


第一部分:Compose 画一帧,到底经历了什么

1.1 先忘掉 View,从“三个工序”说起

如果你是从 View 体系过来的,你脑子里可能有一个默认画面:我改了一个属性,比如 textView.text = "hello",然后系统在某个时刻把这块区域重新画一遍。这个画面里,“改属性”和“重绘”是两件事,中间隔着一个你不太需要关心的调度过程。

Compose 的画面不太一样。它把“画出一帧”拆成了三道严格按顺序执行的工序:

第一道工序叫组合(Composition)。 这一步执行你写的那些 @Composable 函数。但要注意,它执行完之后,产出的不是一堆看得见摸得着的 View,而是一棵“说明书树”。这棵树上写的是:“这里应该有一个 Text,内容是 hello;那里应该有一个 Button,点了会怎样。”它描述的是“要显示什么”,而不是“已经显示出来的东西”。这棵说明书树在 Compose 运行时里有一个更准确的名字,叫组合(composition) ,它由一棵槽表(SlotTable) 承载——你可以把槽表理解成一个高度优化的数据结构,记录每个可组合项的位置、参数、状态和结构关系。后面讲跳过时提到的 $changed 参数和 skipToGroupEnd(),操作的就是这棵槽表。

第二道工序叫布局(Layout)。 拿到说明书树之后,Compose 开始算:每个元素应该占多大地方?应该放在哪个坐标?这一步解决的是“大小和位置”。

第三道工序叫绘制(Drawing)。 位置和大小都定了,最后把像素真正画到屏幕上。

这三道工序的顺序是固定的:先组合,再布局,再绘制。你写的每一行 Compose 代码,最终都会落在其中某一道工序里。这一点非常非常重要,因为同一段逻辑,你放在不同的工序里执行,代价完全不一样。

举个具体的例子。假设你有一个方块,它的水平偏移量 x 会随着用户拖动而变化。你有两种写法:

// 写法 A:在组合阶段读取 x
Box(
    modifier = Modifier.offset(x = x.dp)
)
// 写法 B:在布局阶段读取 x
Box(
    modifier = Modifier.offset { IntOffset(x.roundToInt(), 0) }
)

写法 A 里,x 是在组合阶段被读出来的。这意味着 x 一变,这个 Box 就要重新走一遍组合——重新执行可组合函数、重新生成说明书。写法 B 里,x 是在布局阶段被读出来的,x 变了,组合阶段完全不受影响,只是布局阶段重新算一次位置。

同样一个方块,同样的视觉效果,写法 B 比写法 A 少了一整道工序的开销。这就是“阶段选择”的威力。

现在你可能会问:那是不是所有东西都该用写法 B?不是。写法 B 只能影响布局,如果 x 的变化还需要改变方块里面的内容(比如显示当前坐标的文字),那这部分内容的变化仍然必须在组合阶段处理。阶段选择的本质,是判断“这个变化到底影响了哪一道工序”,然后只在必要的那道工序里处理它。 这个判断,会在后面的课程里反复出现,但它的根就在这一课:你要先知道有三道工序,才能谈在哪道工序里干活。

下面这张图把三道工序和“阶段选择”的关系画在一起:

flowchart TD
    A["状态发生变化"] --> B{"读取发生在哪个阶段"}
    B -->|"组合阶段读取"| C["重新组合(重组)"]
    B -->|"布局阶段读取"| D["重新布局"]
    B -->|"绘制阶段读取"| E["重新绘制"]
    C --> F["组合:生成界面说明树"]
    F --> G["布局:测量与放置"]
    G --> H["绘制:落像素到屏幕"]
    D --> G
    E --> H
    C -.->|"内容影响大小/位置时"| G
    G -.->|"像素发生变化时"| H

1.2 重组,就是第一道工序被重新执行

现在我们来说“重组”。

当某个状态发生变化,Compose 需要更新界面。但“更新界面”不是把三道工序全部重来一遍。Compose 会先判断:这个状态的变化,影响了说明书树的哪些部分?然后把受影响的那部分组合重新执行一次,更新说明书。这个“重新执行组合”的过程,就是重组(Recomposition) 。

所以第一件要纠正的事是:重组不是“重新渲染”,重组只是“重新组合”。 它只发生在第一道工序里。重组之后,可能还需要重新布局、重新绘制,也可能不需要——这取决于重组的内容有没有影响到大小、位置和像素。

这个区分为什么重要?因为很多人把“重组”当成了一个笼统的“刷新”概念,于是看到重组次数多就紧张,看到重组次数少就放心。但重组次数多不一定代表慢——如果每次重组都很轻,一百次重组可能还不如一次昂贵的布局计算。反过来,重组次数少也不一定代表快——为了减少重组而引入的逐元素比较,可能比你省下的重组还贵。

我在第五部分会专门讲这个“重组计数陷阱”。但现在你要先建立一个更精确的画面:重组是组合阶段的行为,它有明确的成本,也有明确的边界。优化重组,本质上是在优化“组合阶段做了多少不必要的工作”。

1.3 状态读取,就是“订阅”

接下来是最核心的机制问题:Compose 怎么知道“哪个状态变化,该重新执行哪部分组合”?

答案藏在一个很朴素的观察里:Compose 知道谁读了状态,因为它就是在读的那一刻记录的。

当你写 val name = myState.value 或者 val name by myState 的时候,你是在组合阶段读取一个状态。就在你读的这一瞬间,Compose 的运行时会把“当前正在执行的那个组合作用域”和“你读的这个状态”关联起来。这个关联,你可以理解成一次订阅:这个作用域订阅了这个状态。

这套机制背后是 Compose 的快照系统(Snapshot System) 。状态对象在快照系统中记录“谁读了我”,运行时在每个可组合项外层维护一个重组作用域(RecomposeScope) 。读取发生时,当前作用域被登记到状态的观察者列表中;状态写入时,快照系统通知所有观察者,把它们标记为 invalid,等待下一帧重新执行。你不需要记住“Snapshot System”这个词,但你需要知道:订阅是精确到作用域的,不是精确到组件的。 一个可组合项内部如果有多个读取点,它们可能属于不同的重组作用域。

用一句话概括:读取即订阅,状态变化即通知订阅者重新执行。

这个机制听起来简单,但它有几个非常重要的推论,值得你停下来想清楚。

推论一:重组的边界,由“谁读了状态”决定,而不是由“状态属于谁”决定。

假设你有一个 UserState,里面存了 name 和 age。组件 A 只读了 name,组件 B 只读了 age。当 name 变化时,只有 A 会重组,B 不会。这不是因为 Compose“聪明地分析了依赖关系”,而是因为 B 根本就没订阅 name,它压根不在通知列表里。

推论二:在组合阶段之外读取状态,不会触发重组。

如果某个状态是在布局阶段被读取的(比如 Modifier.offset { } 的 lambda 里),那么它变化时,触发的是重新布局,而不是重组。同理,在绘制阶段读取的状态(比如 Modifier.drawBehind { } 里),变化时触发的是重绘。

这条推论是后面很多性能优化的理论基础。很多人只知道“把读取推迟到布局/绘制阶段可以减少重组”,但不知道为什么可以减少重组。原因就在这里:读取发生在哪个阶段,状态变化就触发哪个阶段重新执行。 你把读取从组合阶段挪到布局阶段,状态变化自然就不再触发组合阶段了。

推论三:同一个状态可以被多个作用域订阅,变化时它们都会重组。

这听起来是废话,但它解释了一个常见的困惑:“我只改了一个小状态,为什么整个页面都在重组?”因为整个页面里有很多作用域都读了这个状态。解决办法不是“让状态变小”,而是缩小读取范围——把读取这个状态的作用域限制在真正需要它的那个小组件里,而不是在顶层读完了再往下传。

这三个推论合起来,构成了一个可以推理的模型:重组 = 读取了变化状态的那些作用域,重新执行。 你以后遇到任何“为什么这里重组了”,都可以回到这句话来查:谁读了这个状态?读它的作用域有多大?这个作用域是不是可以更小?

把“读取即订阅”的链路画出来,就是下面这样:

flowchart LR
    A["组合阶段读取 state.value"] --> B["快照系统记录:当前重组作用域订阅了该状态"]
    B --> C["状态写入,产生新快照"]
    C --> D["快照系统通知所有观察者"]
    D --> E["相关重组作用域被标记为 invalid"]
    E --> F["下一帧只重新执行这些作用域"]
    F --> G["未订阅该状态的作用域不受影响"]

1.4 一个容易被忽略的例外:子级组合依赖父级布局

上面说“组合 → 布局 → 绘制”是固定顺序。但在少数情况下,这个顺序会被打破,而且打破的方式很有意思。

考虑 BoxWithConstraints。它的子级组合依赖于父级测量出来的最大宽高。也就是说,父级必须先完成布局阶段的测量,才知道“我有多大空间”,然后才能决定“子级应该组合成什么样”。这就导致了一个逆向的时序:父级先测量,子级再组合。

LazyColumn 也有类似的情况。它不会一次性组合所有 item,而是先测量可视区域,算出“哪些 item 在屏幕内”,然后只组合这些 item。所以 lazy 列表的子级组合,也是发生在父级布局之后的。

这个例外为什么值得提?因为它说明“组合一定在布局之前”是一个默认假设,而不是绝对的物理定律。当你写自定义布局或者使用 SubcomposeLayout 的时候,你会主动打破这个假设,让组合依赖布局结果。这个能力很强大,但也有代价——逆向时序意味着更复杂的执行路径,也意味着更难预测的性能特征。第 8 课和第 9 课会专门处理这部分,但第 1 课你需要先知道:默认路径是组合在前,但有例外,而例外是有意为之的设计。

1.5 小结:第一部分你要带走的四句话

好,第一部分讲完了。如果你只记住四句话,应该是这四句:

  1. Compose 画一帧分三道工序:组合、布局、绘制,顺序固定。
  2. 重组是“重新组合”,只发生在第一道工序,不是“重新渲染”。
  3. 状态读取就是订阅,读取发生在哪个阶段,状态变化就触发哪个阶段重新执行。
  4. 重组的边界由“谁读了状态”决定,想缩小重组范围,就去缩小读取范围。

有了这四句话,我们就可以进入下一部分了。下一部分要回答一个更具体的问题:既然重组是可以被跳过的,那“跳过”到底需要什么条件?


第二部分:跳过——Compose 的性能契约

2.1 如果没有“跳过”,Compose 会是什么样

在讲“跳过”之前,我们先做一个思想实验:假设 Compose 没有跳过机制,会怎样?

那意味着,只要有任何状态变化,整棵组合树都会被重新执行。你改了一个输入框的文字,整个页面从顶到底所有可组合函数全部重跑一遍。滚动列表时,每一帧都要把所有 item 重新组合一遍。

这个模型在简单的页面上勉强能跑,但在真实业务里会立刻崩掉。因为组合阶段是有成本的:每个可组合函数要执行、要分配对象、要比较参数、要更新槽表。整棵树重跑的代价,在复杂页面上是不可接受的。

所以 Compose 从设计之初就必须有一个机制:如果某个可组合项的输入没有变化,就跳过它,直接复用上一轮的结果。 这个机制就叫跳过(Skipping) 。

跳过不是锦上添花的优化,它是 Compose 性能模型的地基。没有它,Compose 在复杂 UI 上根本无法和 View 体系竞争。

但跳过不是免费的午餐。它有一个前提,这个前提就是这一部分要讲清楚的核心:跳过的前提,是运行时能够判断“这个可组合项的参数没有变化”。 如果判断不了,或者判断结果是“变了”,跳过就不会发生。

2.2 运行时怎么判断“参数没变”?——从最朴素的想法开始

让我们从最简单的场景开始,一步步把这个问题想清楚。

假设有这样一个可组合项:

@Composable
fun Greeting(name: String) {
    Text("Hello, $name")
}

父级在调用它时传入了 name = "Alice"。下一轮重组,父级又传入了 name = "Alice"。运行时能不能跳过 Greeting?

直觉上当然能——两个 "Alice" 是一模一样的字符串。运行时确实也是这么做的:它用 equals() 比较新旧两个 String,发现相等,于是跳过。

现在换一个参数类型:

data class User(val name: String, val age: Int)

@Composable
fun UserCard(user: User) {
    Text("${user.name}, ${user.age}")
}

父级传入 User("Alice", 20),下一轮又传入 User("Alice", 20)。这是两个不同的对象实例,但它们的字段完全相同。运行时用 equals() 比较(data class 自动生成的 equals() 是逐字段比较),发现相等,于是跳过。

再换一个:

data class MutableUser(var name: String, var age: Int)

这次字段是 var 了。父级传入 MutableUser("Alice", 20),然后在某处直接改了 user.name = "Bob",但对象引用没变。下一轮重组,运行时看到的是同一个对象实例。它会跳过吗?

这就是问题开始变得微妙的地方。运行时只跟踪 State 对象的变化,它不知道你直接改了 var 字段。所以如果它用 equals() 比较,发现还是同一个对象,字段内容可能已经变了但 equals() 可能返回 true(如果没改)也可能返回 false(如果改了但没通知)。这里的核心问题是:Compose 无法可靠地知道这个可变对象的内部是否发生了变化,所以它不敢信任这个对象是“稳定”的。

这就是稳定性(Stability) 这个概念要解决的问题。

2.3 稳定性:一个类型“可以被信任”是什么意思

Compose 对“稳定类型”的定义是精确的:

如果一个类型是不可变的,或者 Compose 能够知道它的值在重组之间是否发生了变化,那么它就是稳定的。

拆开来看,稳定有两种来源:

第一种来源:不可变。 所有属性都是 val,而且属性类型本身也都是稳定的。这种类型一旦创建就不会变,所以运行时可以放心地用 equals() 比较——如果相等,那它确实没变;如果不等,那它确实变了。data class User(val name: String, val age: Int) 就属于这一类。在 Compose 编译器构建的模块内,这种类型会被自动推断为稳定,不需要加任何注解。

第二种来源:你向运行时做出承诺。 有些类型内部确实有可变状态,但你能保证“它的变化会通过 Compose 能观察到的方式(比如 State)传播”。对于这种类型,你可以用 @Stable 或 @Immutable 注解告诉编译器:“相信我,它是稳定的。” 运行时收到这个承诺后,就不再追问内部机制,直接用 equals() 比较。

不稳定的类型就是两类都不满足的。最典型的例子是 List、Set、Map 这些标准集合接口。你可能会说:“我传进去的 listOf(...) 明明是不可变的啊。” 对,但 Compose 编译器看到的是 List 这个接口,它无法确认运行时拿到的具体实现是不是真的不可变(MutableList 也实现了 List),所以它只能保守地把 List 标记为不稳定。

另一个典型例子是带 var 字段的 data class。运行时不知道你什么时候会改那个 var,所以它不敢信任“引用相同就等于内容相同”。

这里有一个容易被忽略的细节:稳定性推断有模块边界。如果 User 定义在启用了 Compose 编译器的模块中,编译器会分析它的字段并推断稳定性;如果它定义在一个普通 Kotlin 模块(没有 Compose 编译器插件)中,编译器拿不到足够的推断信息,可能保守地把它标记为不稳定。第 2 课会展开这个边界问题,但现在你应该知道:“我的 data class 全是 val,所以它一定稳定”这句话,在跨模块场景下不成立。

2.4 稳定性怎么影响跳过?——比较协议的两条分支

现在把稳定性和跳过连起来。运行时在决定“要不要跳过”时,会根据参数的稳定性走不同的比较路径:

稳定参数 → 用 equals()(结构相等)比较。 因为运行时相信这个类型的“相等”就是“内容相等”,所以它可以放心地逐字段比较。相等就跳过,不等就重组。

不稳定参数 → 用 ===(引用相等)比较。 因为运行时无法判断内容是否变化,它只能退而求其次:如果引用都没变,那就当作没变;如果引用变了,那它无法判断内容是否也变了,只能保守地认为“可能变了”,于是不跳过。

这个双轨制,就是理解所有“为什么我的代码没有被跳过”问题的钥匙。

让我们用它来分析几个常见场景:

场景一:传 List。

@Composable
fun ItemList(items: List<Item>) { ... }

List 是不稳定类型,所以运行时用 === 比较。如果父级每次重组都传同一个 List 实例,=== 成立,可以跳过。但如果父级在每次重组时都 items.filter { ... } 一下,那就每次都是新实例,=== 永远失败,永远不跳过。

场景二:传 lambda。

@Composable
fun Button(onClick: () -> Unit) { ... }

lambda 在旧版 Compose 里是不稳定的,因为每次重组都会创建新的 lambda 实例。强跳过模式(下面会讲)通过编译器自动记忆化解决了这个问题。但在没有强跳过的情况下,Button 的参数每次都是新 lambda,=== 永远失败,永远不跳过。

场景三:传 data class 但里面有 var。

data class Form(var text: String)

不稳定,用 === 比较。如果父级每次传新实例,不跳过;如果传同一实例但改了 var,运行时不知道,可能错误地跳过(这就是为什么 var 字段危险)。

把比较协议的两条分支和强跳过的影响画成一张判定图:

flowchart TD
    A[&#34;可组合项准备重组&#34;] --> B{&#34;身份是否稳定(key/位置一致)&#34;}
    B -->|&#34;否&#34;| C[&#34;视为新项,直接重新组合&#34;]
    B -->|&#34;是&#34;| D{&#34;参数类型是否稳定&#34;}
    D -->|&#34;稳定&#34;| E[&#34;用 equals() 比较新旧参数&#34;]
    D -->|&#34;不稳定&#34;| F[&#34;用 === 比较新旧参数引用&#34;]
    E --> G{&#34;比较结果相等&#34;}
    F --> H{&#34;引用相同&#34;}
    G -->|&#34;是&#34;| I[&#34;跳过:复用上一轮结果&#34;]
    G -->|&#34;否&#34;| J[&#34;重新执行该可组合项&#34;]
    H -->|&#34;是&#34;| I
    H -->|&#34;否&#34;| J
    I --> K[&#34;skipToGroupEnd() 跳过函数体&#34;]

2.5 强跳过模式:它改变了什么,又没改变什么

从 Kotlin 2.0.20 开始,Compose 默认启用了强跳过模式(Strong Skipping Mode) 。这是一个非常重要的变化,但它经常被误解,所以我要把“它改变了什么”和“它没改变什么”分得很清楚。

强跳过改变了什么:

第一,所有可重启的可组合项都变得可跳过,不管它有没有不稳定参数。在旧模式下,一个可组合项只要有一个不稳定参数,整个可组合项就不可跳过。强跳过取消了这个“连坐”规则——不稳定参数仍然存在,但它们不再让整个可组合项失去跳过资格。

第二,编译器自动记忆化可组合项内部的 lambda。旧模式下,每次重组都会为传给子项的 lambda 分配新实例,导致子项参数永远在变。强跳过模式下,编译器用 remember 包裹 lambda,键是 lambda 捕获的变量。只要捕获没变,lambda 引用就保持稳定,子项的 === 比较就能通过。

强跳过没改变什么:

第一,不稳定参数仍然用 === 比较。强跳过没有把 List 变成稳定类型,也没有让 === 变成 equals()。如果你每次重组都创建新 List 实例,=== 还是失败,跳过还是不发生。强跳过只是让“即使有一个不稳定参数,其他稳定参数的比较仍然有意义”,它没有消除“新实例导致引用变化”这个根本约束。

第二,稳定参数仍然用 equals() 比较。这意味着如果你为了“让集合变稳定”而引入 ImmutableList 或给集合模型加 @Immutable,你可能会引入逐元素 equals() 比较的开销。在一个大列表上,这个比较本身可能比重组还贵。强跳过没有让这个代价消失。

第三,跳过本身仍然有成本。运行时要做槽表遍历、参数比较、组边界检查。重组次数下降不等于性能一定提升。这个陷阱我在第五部分会专门讲。

所以一个准确的总结是:强跳过把默认值从“不稳定参数导致不可跳过”改成了“不稳定参数用引用相等性参与比较”,它让跳过更容易发生,但它没有改变“你分配了新实例,引用就变了”这个物理事实,也没有消除跳过本身的成本。

你在做优化时,判断逻辑应该是这样的:先问“这个可组合项有没有被跳过”,如果没有,再问“是哪个参数的比较失败了”,然后问“这个参数为什么每轮都是新实例”。强跳过能帮你解决 lambda 的问题,但它帮不了你解决“你每次都在 filter 出一个新列表”的问题。

2.6 跳过在编译器里长什么样

这一小节稍微偏底层,但值得讲,因为它能帮你把“代码看起来应该被跳过”和“实际有没有被跳过”区分开。

Compose 编译器会为每个可重启的可组合函数生成一个隐藏参数 $changed。这个参数是一个位掩码,用来编码“这一轮参数和上一轮相比,哪些变了”。

在函数入口,编译器插入的逻辑大致是这样的:拿当前参数和槽表(SlotTable)里记录的上一轮参数比较,如果判定“无变化”,就调用 composer.skipToGroupEnd(),直接跳到这个组的末尾,整个函数体不执行。

这意味着跳过是一个编译期生成、运行期执行的组级操作。它不是你在代码里写个 if 就能控制的东西,而是编译器根据你的参数类型“允许”或“禁止”的能力。

理解这一点,你就能明白为什么“我在函数体里加个判断”不能替代跳过:函数体根本没执行,你的判断也没机会跑。跳过发生在函数体之前,发生在参数比较阶段。

第 2 课会教你怎么用编译器报告和反编译来验证一个可组合项到底能不能被跳过。但第 1 课你要先建立这个直觉:跳过是编译器给你的能力,它取决于参数类型,不取决于你在函数体里写了什么。

2.7 小结:第二部分你要带走的四句话

  1. 跳过是 Compose 性能的地基,没有它复杂 UI 无法运行。
  2. 跳过的前提是运行时能判断“参数没变”,判断方式取决于参数的稳定性。
  3. 稳定参数用 equals() 比较,不稳定参数用 === 比较;强跳过让不稳定参数也能参与比较,但没有改变“新实例导致引用变化”这个事实。
  4. 跳过是编译器生成的组级操作,取决于参数类型,不取决于函数体里的逻辑。

好了,现在你知道“跳过”是怎么回事了。但还有一个问题没回答:就算参数稳定、跳过发生了,Compose 怎么知道“这是同一个可组合项”?换句话说,身份是怎么确定的?这就是第三部分要讲的 key。


第三部分:身份——key 到底在解决什么问题

3.1 一个真实会遇到的 bug

先看一个具体的 bug,比抽象地讲“身份”要直观得多。

假设你有一个待办事项列表,每个 item 有一个展开/折叠状态,用 remember 存着:

@Composable
fun TodoList(todos: List<Todo>) {
    Column {
        todos.forEach { todo ->
            var expanded by remember { mutableStateOf(false) }
            TodoRow(
                todo = todo,
                expanded = expanded,
                onToggle = { expanded = !expanded }
            )
        }
    }
}

现在列表里有三项:A、B、C。你把 B 展开了。然后你删除了 A。列表变成 B、C。

按你的直觉,B 应该还是展开的,C 应该还是折叠的。但实际会发生什么?B 会变回折叠,C 会继承 B 的展开状态。

为什么?因为 Compose 默认用位置来判断“是不是同一个可组合项”。删除 A 之后,原来的 B 移动到了位置 0,而位置 0 上原来存的是 A 的状态(折叠)。运行时看到“位置 0 上有一个可组合项”,就认为它还是原来那个,于是复用了 A 的状态。C 移动到位置 1,复用了 B 的状态(展开)。

这不是 bug,这是位置身份的正确行为。运行时不知道“B 还是那个 B”,它只知道“位置 0 上还是那个位置 0”。在你看来 B 移动了,在运行时看来位置 0 换了个内容。

3.2 key 做的事:把身份从“位置”换成“业务标识”

修复方式很直接:给每个 item 一个稳定的业务标识,并告诉 Compose 用这个标识来判断身份。

@Composable
fun TodoList(todos: List<Todo>) {
    Column {
        todos.forEach { todo ->
            key(todo.id) {
                var expanded by remember { mutableStateOf(false) }
                TodoRow(...)
            }
        }
    }
}

key(todo.id) { ... } 的意思是:这个块里面的可组合项,身份由 todo.id 决定,不由位置决定。 现在删除 A 之后,B 的 id 还是 B 的 id,运行时认出“这还是 B”,于是保留 B 的展开状态;C 同理。状态不再错位。

在 LazyColumn 里也是一样的道理,只是写法变成了 items(list, key = { it.id })。

3.3 关于 key 的三条硬规则

讲到这里,可以给出三条可以直接写进团队规范的规则。

规则一:列表项必须用业务唯一标识作为 key。

index 作为 key 只适用于“只追加、永不删除、永不重排”的静态列表。真实业务里几乎不存在这种列表——筛选会改变顺序,删除会让下标漂移,排序会重排。一旦下标漂移,位置身份的 bug 就会重现。

随机 UUID 作为 key 比 index 更糟。每次重组都生成新 UUID,等于告诉运行时“这些都是全新的 item”,结果就是每次重组都重建所有 item,状态全丢,性能极差。

规则二:key 的影响不止于 remember 状态。

LazyColumn 的 item 位移动画(animateItemPlacement)依赖 key 来判断“哪个 item 移动到了哪里”。key 错了,动画会“飞错行”。LazyColumn 的复用池和 item 状态保存也以 key 为锚点。所以 key 不是“锦上添花的动画配置”,它是列表正确性的基础设施。

规则三:key 也可以用在非列表场景,但要谨慎。

在普通的 Column 里,如果有一个条件分支,分支里包含 remember 状态,你也可以用 key 来稳定身份,避免兄弟结构变化时状态被错误复用。但 Compose 文档也警告过:rememberSaveable 的自定义 key 可能绕过位置作用域,导致意外的状态共享或丢失。key 是精确工具,不是越多越好。

3.4 身份、重组、跳过三者的关系

最后把这一部分和前面两部分连起来。

身份决定“这是不是同一个可组合项”。 如果身份判定为“不同”,运行时不会去比较参数、不会考虑跳过,而是直接把它当作新项重新组合。所以 key 错了,跳过就无从谈起——因为运行时根本没把它们当成同一个东西。

身份稳定,跳过才有意义。 如果身份稳定,运行时才会进入“比较参数、决定跳过”的流程。所以 key 正确是跳过生效的前提之一。

跳过是参数层面的优化,身份是结构层面的正确性。 两者不是一回事。身份错了,是 bug;跳过没生效,是性能问题。先保证身份正确,再谈跳过优化。顺序不能反。

三者的先后关系可以这样理解:

flowchart TD
    A[&#34;列表数据变化(删除/重排)&#34;] --> B{&#34;是否使用业务 key&#34;}
    B -->|&#34;否,按位置判定&#34;| C[&#34;位置身份错位&#34;]
    C --> D[&#34;remember 状态被错误复用&#34;]
    D --> E[&#34;状态错位 bug + 动画飞错行&#34;]
    B -->|&#34;是,业务唯一标识&#34;| F[&#34;身份稳定,认出同一个 item&#34;]
    F --> G[&#34;进入参数比较流程&#34;]
    G --> H{&#34;参数是否变化&#34;}
    H -->|&#34;未变&#34;| I[&#34;跳过,复用上一轮组合&#34;]
    H -->|&#34;变化&#34;| J[&#34;仅重组该 item&#34;]

3.5 小结:第三部分你要带走的四句话

  1. Compose 默认用位置判断身份,位置身份在动态列表里会导致状态错位。
  2. key 把身份从位置切换到业务标识,是列表正确性的基础设施。
  3. 列表 key 必须是业务唯一标识,index 和随机值都会出问题。
  4. 身份稳定是跳过生效的前提,先保正确性,再谈性能。

第四部分:副作用——它依附于组合,而不是“每次重组都跑”

4.1 一个常见的误解

很多人对副作用的第一印象是:“LaunchedEffect 里的代码在重组之后执行。” 这个理解不算完全错,但它漏掉了最关键的部分,而这个遗漏会在进阶阶段制造很难排查的 bug。

LaunchedEffect(key) 的真实行为是:

  • 当它进入组合时,启动一个协程,执行 block;
  • 当它离开组合时,取消这个协程;
  • 当 key 变化时,取消旧协程,用新 key 启动新协程;
  • 如果 key 没变,即使宿主可组合项因为其他状态变化而重组,协程不会重启,block 不会重新执行。

最后这条是重点。很多人以为“重组了,effect 就会重跑”,其实不是。effect 的存活时间由 key 决定,不由重组次数决定。

4.2 三个副作用 API 的对照

Compose 提供了几个常用的副作用 API,它们的协议各不相同,值得放在一起对比。

LaunchedEffect(key):进入组合时启动协程,离开时取消,key 变化时重启。适合挂起操作、一次性事件、状态驱动的循环。

DisposableEffect(key):进入组合时执行注册逻辑,离开时执行 onDispose 里的清理逻辑,key 变化时先 dispose 再重新注册。适合注册/注销监听器、绑定/解绑资源。它的特点是强制你成对地写注册和清理,这是它比 LaunchedEffect 更适合资源管理的原因。

SideEffect:每次成功重组之后执行,不涉及协程,没有 key,也没有清理。适合“把 Compose 状态同步给非 Compose 对象”这类“每次重组都要做一次”的发布操作。

用一张表总结:

API触发时机key 变化时离开组合时典型用途
LaunchedEffect(key)进入组合 / key 变化取消旧协程,启动新协程取消协程挂起操作、一次性事件
DisposableEffect(key)进入组合 / key 变化先 dispose,再重新注册执行 dispose注册/注销监听器、绑定/解绑资源
SideEffect每次成功重组之后不适用(无 key)无向非 Compose 代码发布状态

这张表的每一行都在回答同一个问题的不同侧面:副作用的生命周期跟随组合,不跟随“函数被调用的次数” 。你把这句话想清楚,很多“为什么 effect 没跑”和“为什么 effect 跑了两次”的困惑就迎刃而解了。

4.3 副作用在帧内的时序位置

上一节说 SideEffect “在每次成功重组之后执行”,这句话需要再精确一点:它在组合阶段完成之后、布局阶段开始之前执行。理解这个时序位置,能帮你判断哪些操作可以放在 SideEffect 里,哪些不行。

一帧内的大致顺序是:组合(执行可组合函数)→ SideEffect 及其他副作用 → 布局 → 绘制。LaunchedEffect 的协程体则在组合完成后、由协程调度器在合适的时机执行,不保证在同一帧的布局之前完成——它可能跨越多个帧。DisposableEffect 的注册逻辑在进入组合时执行,清理逻辑在离开组合时执行,同样遵循这个时序框架。

这个时序解释了一个常见困惑:“为什么我在 SideEffect 里读取布局结果,拿到的是上一帧的值?”因为 SideEffect 在布局之前执行,当前帧的布局还没发生。如果你需要读取布局结果,应该用 Modifier.onGloballyPositioned 或 onSizeChanged,它们发生在布局阶段之后。

第 5 课会把每个 API 的时序细节展开,但第 1 课你需要建立这个框架:副作用不是“在重组旁边随便跑”,它们有明确的帧内位置,这个位置决定了它们能读到什么、不能读到什么。

把副作用在帧内的时序位置画出来:

flowchart LR
    A[&#34;组合阶段执行&#34;] --> B[&#34;SideEffect:每次成功重组后执行&#34;]
    B --> C[&#34;布局阶段&#34;]
    C --> D[&#34;绘制阶段&#34;]
    A --> E[&#34;LaunchedEffect:进入组合或 key 变化时启动协程&#34;]
    A --> F[&#34;DisposableEffect:进入组合注册,离开组合 dispose&#34;]
    E -.->|&#34;协程在帧后异步执行&#34;| G[&#34;挂起任务 / 一次性事件&#34;]
    F -.->|&#34;与组合生命周期严格对称&#34;| H[&#34;监听器注册与注销&#34;]

4.4 rememberUpdatedState:当长期存在的 effect 需要“最新值”

现在讲一个进阶阶段非常常见、但初学者容易忽略的问题。

LaunchedEffect 和 DisposableEffect 的共同特征是长期存在:它们可能跨越很多次重组而不重启。这就带来一个结构性风险:长期存在的协程或对象,捕获的是创建时那一轮组合中的引用。

看一个具体的例子:

@Composable
fun NotificationHost(
    state: NotificationState,
    onTimeout: (Notification) -> Unit
) {
    state.currentNotification?.let { notification ->
        LaunchedEffect(notification) {
            delay(NotificationTimeout)
            onTimeout(notification) // 这里用的是哪个 onTimeout?
        }
    }
}

LaunchedEffect(notification) 的 key 是 notification。只要 notification 没变,effect 就不会重启。但 onTimeout 是父级每次重组都可能传入的新 lambda。effect 内部捕获的 onTimeout 是effect 首次启动时的那个版本。如果父级后来传入了一个新的 onTimeout(比如它捕获了新的状态),effect 内部仍然调用旧的,因为协程没有重启,它手里的引用没变。

这个问题的修复方式是用 rememberUpdatedState:

val currentOnTimeout by rememberUpdatedState(onTimeout)

LaunchedEffect(notification) {
    delay(NotificationTimeout)
    currentOnTimeout(notification) // 始终调用最新版本
}

rememberUpdatedState 的机制是:它返回一个 State 容器,每次重组时把新值写进容器,但容器的引用保持不变。长期存在的 effect 持有的是这个稳定容器,读容器时自然拿到最新值,而 effect 本身不需要取消和重启。

这个模式在第 3 课和第 5 课会展开。但在第 1 课,它的意义是给你一条判断规则:只要一个 effect 的生命周期可能长于“当前这次组合”,而它内部又引用了在组合期间计算的参数或 lambda,你就应该检查是否需要用 rememberUpdatedState 来解耦“effect 的存活”和“值的更新”。

这条规则不是让你到处加 rememberUpdatedState,而是让你在写长期 effect 时多问一句:“它捕获的东西,会不会在它存活期间过期?”

4.5 小结:第四部分你要带走的四句话

  1. 副作用生命周期跟随组合,不跟随“函数被调用次数”。
  2. LaunchedEffect 的 key 不变就不重启,DisposableEffect 强制成对注册与清理,SideEffect 每次重组后执行。
  3. 副作用有明确的帧内时序位置,决定了它们能读到什么。
  4. 长期存活的 effect 若引用组合期间计算的 lambda/参数,用 rememberUpdatedState 解耦存活与更新。

第五部分:几个“看起来对、实际上错”的高频模式

前面四部分讲的是原理。这一部分讲几个具体的反模式,帮你把原理落到代码上。

5.1 在组合函数体里做重活

@Composable 函数会因重组而多次执行。函数体里的任何计算——格式化日期、排序列表、创建对象——都可能在一次滚动中执行很多次。这不一定是 bug,但你需要有意识地判断:这个计算是不是真的需要每次都做?

一个典型的反模式:

@Composable
fun FilteredList(items: List<Item>) {
    val filtered = items.filter { it.active } // 每次重组都创建新 List
    ItemColumn(filtered)
}

这里有两个问题。第一,filter 本身有成本,每次重组都做一遍。第二,更隐蔽的问题是 filtered 每次都是新实例,ItemColumn 的参数是一个不稳定类型(List),用 === 比较永远失败,所以 ItemColumn 永远无法跳过。

修复方式不是“加个 @Immutable 骗编译器”,而是把计算移到合适的位置:用 remember(items) 缓存结果,或者用 derivedStateOf 做状态派生。第 4 课会专门讲派生状态的选择判据,但第 1 课你要能识别这个模式。

5.2 把 lambda 版本和非 lambda 版本混为一谈

回到第一部分那个 offset 的例子。Modifier.offset(x.dp) 和 Modifier.offset { IntOffset(...) } 看起来只是写法不同,实际上它们读取状态的阶段不同,触发重组的条件也不同。

这不是“lambda 版本更好”的简单结论,而是一个阶段选择问题:如果某个值的变化只需要影响布局而不影响组合内容,把它推迟到布局阶段读取就是正确的杠杆。判断的依据是“这个变化影响了哪道工序”,而不是“哪种写法更高级”。

5.3 把重组计数当成性能结论

这个陷阱值得单独说,因为它太常见了。

Layout Inspector 的重组计数是有用的诊断信号,但它不是性能结论。官方文档明确警告过:跳过本身有槽表遍历和参数比较的开销,重组计数不能替代基准测试。应该用组合跟踪(composition tracing)和 Macrobenchmark 验证真实帧时序和 CPU 影响。

一个可组合项重组次数从 100 降到 10,如果每次重组本身极轻,整体收益可能微乎其微。反过来,为了减少重组而引入的逐元素 equals() 比较,可能在大列表上制造新的热点。

所以正确的优化流程是:先用工具确认瓶颈在组合阶段,再用重组计数定位高开销的可组合项,最后用基准测试验证优化真的有效。三步缺一不可。第 18 课会专门讲这套工具链,但第 1 课你要先拒绝“重组次数越少越好”这个简化结论。


第六部分:一个可以带走的判断框架

把这一课压缩成五个可以在代码审查中直接使用的问题:

问题一(阶段): 这个状态是在组合阶段读取的,还是在布局/绘制阶段读取的?如果是后者,我是不是在不必要地触发重组?

问题二(跳过): 这个可组合项的参数里,有没有每次重组都会新建的集合、lambda 或可变类型实例?如果有,=== 比较会失败,跳过不会发生。参数稳定性有没有被编译器报告确认过,而不是靠猜测?

问题三(身份): 列表项的 key 是不是业务唯一标识?有没有用 index 或随机值?条件分支里的可组合项需不需要 key 来稳定身份?

问题四(副作用): 这个 effect 的存活时间可能长于当前组合吗?如果可能,它内部引用的 lambda 或参数需不需要 rememberUpdatedState 来保证“最新值”而不是“创建时的值”?清理逻辑和注册逻辑是否严格对称?

问题五(诊断): 我是在用重组计数做判断,还是已经用组合跟踪和基准测试确认了真实性能影响?

这五个问题没有一个是“API 用法”问题。它们全部是运行时行为判断问题。这就是“会写”和“写对”的分界线:会写的人知道 LaunchedEffect 怎么调用,写对的人知道它在什么条件下不应该被重启;会写的人知道 data class 可以当参数,写对的人知道它的稳定性在什么条件下会失效、跳过的比较协议在哪个环节断掉。


第七部分:课后习题(15 道)

习题 1(概念辨析·选择题)——三阶段与重组的归属

题目: 下列关于 Compose 一帧渲染流程的说法,哪一项是正确的?

A. 重组同时发生在组合、布局、绘制三个阶段 B. 重组只发生在组合阶段,它是重新执行受影响的 @Composable 函数 C. 重组等同于重新渲染,只要重组发生,绘制阶段必然重新执行 D. 布局阶段先于组合阶段执行,组合依赖布局结果

参考答案:B

解读: 本题考查本课最基础的心智模型。Compose 一帧分组合 → 布局 → 绘制三道工序,顺序固定。重组是“重新组合”,只发生在第一道工序。A 错在把重组泛化到三个阶段;C 错在把“重组”和“重新渲染”混为一谈——重组后是否需要重新布局、重绘,取决于重组内容是否影响大小、位置和像素;D 错在颠倒了默认顺序,只有 BoxWithConstraints、LazyColumn 等少数场景才会出现“子级组合依赖父级布局”的逆向时序,且这是例外而非常规。


习题 2(概念辨析·判断题)——重组与重绘的关系

题目: 判断正误:只要一个可组合项发生了重组,它就一定会触发重新绘制。

参考答案:错误。

解读: 重组只更新组合树(说明书),它可能改变了内容,也可能只是重新执行了函数但产出相同。即使产出不同,只要变化不影响可见像素(例如只是内部状态对象的替换),绘制阶段也可能被跳过。Compose 的三个阶段各自有独立的失效判断,重组不等于重绘。这道题针对的是“重组 = 刷新”这个最常见的错误直觉。


习题 3(概念辨析·选择题)——状态读取即订阅

题目: 有如下代码,当 count 从 0 变为 1 时,哪个作用域会进入重组候选?

@Composable
fun Parent() {
    val count by remember { mutableStateOf(0) }
    Column {
        Text("Count: $count")          // 位置 A
        Button(onClick = { }) { Text("OK") }  // 位置 B
    }
}

A. 整个 Parent、Column、位置 A、位置 B 全部重组 B. 只有读取了 count 的 Text(位置 A)所在的作用域重组 C. 只有 Parent 重组,子级不受影响 D. 无法确定,取决于 Column 是否稳定

参考答案:B

解读: 读取即订阅。count 只在 Text("Count: $count") 这一行被读取,因此只有该读取所在的重组作用域被标记为 invalid。位置 B 的 Button 没有读取 count,不在订阅列表中。A 是最常见的误解——“状态变了所以整个页面刷新”;C 错在把重组边界放在 Parent 函数入口,实际上 Parent 函数体确实执行了 remember 和 Column,但真正订阅 count 的是 Text 参数计算所在的作用域。重组的边界由“谁读了状态”决定,不由“状态声明在哪里”决定。


习题 4(代码分析·阶段选择)——offset 的两种写法

题目: 下面两种写法在 offsetX 变化时,分别会触发哪些阶段的重新执行?请说明原因,并指出哪种写法在“只需要移动位置、不改变内容”的场景下开销更小。

// 写法 A
Box(modifier = Modifier.offset(x = offsetX.dp))

// 写法 B
Box(modifier = Modifier.offset { IntOffset(offsetX.roundToInt(), 0) })

参考答案:

  • 写法 A:offsetX 在组合阶段被读取(offsetX.dp 在组合时求值),因此 offsetX 变化会触发重组,进而可能重新布局、重绘。
  • 写法 B:offsetX 在布局阶段的 lambda 内被读取,因此 offsetX 变化只触发重新布局,跳过组合阶段。

在“只需要移动位置”的场景下,写法 B 开销更小,因为它少执行了一整道组合工序。

解读: 本题考察“读取发生在哪个阶段,状态变化就触发哪个阶段重新执行”这条核心推论。注意不要把它简化成“lambda 版本总是更好”——如果 offsetX 的变化还需要改变 Box 内部显示的文字内容,那部分内容的变化仍然必须在组合阶段处理。阶段选择的判据是“这个变化影响了哪道工序”,不是“哪种写法更高级”。


习题 5(概念辨析·选择题)——稳定性的判定

题目: 下列类型中,在 Compose 编译器构建的模块内,最可能被自动推断为稳定的是:

A. List<String> B. data class User(var name: String, val age: Int) C. data class User(val name: String, val age: Int) D. MutableList<String>

参考答案:C

解读: A 和 D 都是集合接口/可变集合,Compose 编译器无法确认其运行时实现是否真的不可变,保守标记为不稳定。B 含有 var 字段,运行时无法可靠追踪其内部变化,不稳定。C 所有属性为 val,且 String、Int 本身稳定,因此会被自动推断为稳定。注意:稳定性推断有模块边界——如果 User 定义在未启用 Compose 编译器的模块中,推断结果可能不同,第 2 课会展开这一点。


习题 6(概念辨析·判断题)——强跳过模式的能力边界

题目: 判断正误:强跳过模式(Strong Skipping Mode)启用后,即使一个可组合项接收 List 参数,只要列表内容相同,它也能被跳过。

参考答案:错误。

解读: 强跳过模式让不稳定参数也能参与跳过比较,但比较方式是 ===(引用相等),不是 equals()。如果父级每次重组都传入新的 List 实例(例如 items.filter { ... } 的结果),即使内容完全相同,=== 也为 false,跳过仍然不会发生。强跳过解决的是“不稳定参数导致整个可组合项不可跳过”的连坐问题,以及 lambda 自动记忆化问题,它没有把 List 变成稳定类型,也没有把引用比较升级为内容比较。这是本课最容易被误读的知识点之一。


习题 7(场景判断·根因分析)——跳过失效的双重原因

题目: 以下代码中,ItemColumn 在每次父级重组时都无法被跳过。请指出两个原因,并给出至少一种修复思路。

@Composable
fun FilteredList(items: List<Item>) {
    val filtered = items.filter { it.active }
    ItemColumn(filtered)
}

参考答案:

原因一: items.filter { ... } 每次重组都创建新的 List 实例。List 是不稳定类型,跳过比较使用 ===,新实例导致引用比较永远失败。

原因二: filter 本身在组合阶段执行,每次重组都重复计算,属于“在组合函数体里做重活”的反模式。

修复思路(任选其一或组合):

  1. 用 remember(items) { items.filter { it.active } } 缓存过滤结果,使实例在 items 不变时保持稳定;
  2. 将过滤逻辑上移到状态层(ViewModel 或 derivedStateOf),让 ItemColumn 接收已派生好的稳定数据;
  3. 如果业务允许,让 ItemColumn 接收原始 items 和过滤条件,在子级内部按需处理,避免父级每轮分配新集合。

解读: 本题考查“稳定性 + 跳过 + 组合阶段成本”三个知识点的联动。很多开发者只看到“重组次数多”,却分不清是“参数不稳定导致跳过失效”还是“组合阶段计算太重”。本题两者兼有。修复时要注意:不要用 @Immutable 注解“骗”编译器,那只是改变比较协议,不消除新实例分配和过滤计算本身的成本。


习题 8(概念辨析·选择题)——key 的身份语义

题目: 一个 LazyColumn 的 items 使用 index 作为 key。用户删除了列表中间的一项。下列描述最准确的是:

A. 不会有任何问题,index 是合法 key B. 只有动画会出错,状态不受影响 C. 被删除项之后的所有 item 可能发生 remember 状态错位,因为位置身份与业务身份不再对应 D. Compose 会自动检测并修正 key 冲突

参考答案:C

解读: 使用 index 作为 key 时,删除中间项会导致后续 item 的下标整体前移,key 值随之改变。Compose 按 key 匹配身份,key 变了就视为“不同的 item”,于是 remember 状态无法跟随正确的业务实体,出现错位。B 错在低估了影响范围——不只是动画,remember、rememberSaveable、复用池都以 key 为锚点。D 错在 Compose 不会“自动修正”语义层面的 key 错误,它只按你给的 key 执行。正确做法是使用业务唯一标识(如 todo.id)。


习题 9(代码分析·位置身份 bug 复现)——删除第一项后状态怎么走

题目: 阅读代码,描述删除列表第一项 A 后,B 和 C 的 expanded 状态分别会发生什么,并解释原因。

@Composable
fun TodoList(todos: List<Todo>) {
    Column {
        todos.forEach { todo ->
            var expanded by remember { mutableStateOf(false) }
            TodoRow(todo, expanded) { expanded = !expanded }
        }
    }
}
// 初始:A(折叠)、B(展开)、C(折叠),删除 A

参考答案:

删除 A 后:B 变为折叠,C 变为展开。

原因:forEach 中没有使用 key,Compose 默认按位置判断身份。删除 A 后,B 移动到位置 0,而位置 0 上原本保存的是 A 的 remember 状态(折叠),因此 B “继承”了 A 的状态;C 移动到位置 1,继承了 B 原本的展开状态。运行时并不知情“B 还是那个 B”,它只认位置。

解读: 本题与习题 8 互为补充:习题 8 考 LazyColumn 的 key 参数,本题考普通 Column 中 key { } 的必要性。修复方式是在 forEach 内用 key(todo.id) { ... } 包裹。同时要注意,这不是 Compose 的 bug,而是位置身份语义的正确行为——理解这一点,才能在代码审查中把它识别为“缺 key”,而不是“Compose 状态管理有问题”。


习题 10(概念辨析·简答题)——LaunchedEffect 的重启条件

题目: 请简述 LaunchedEffect(key) 在以下三种情况下的行为:(1)首次进入组合;(2)key 不变但宿主因其他状态重组;(3)key 变化。

参考答案:

  1. 首次进入组合: 启动一个协程,执行 block。
  2. key 不变但宿主重组: 协程不会重启,block 不会重新执行。effect 的存活由 key 决定,不由重组次数决定。
  3. key 变化: 取消旧协程,以新 key 启动新协程,block 重新执行。

解读: 第(2)种情况是本题的核心区分点。很多初学者以为“重组了 effect 就会重跑”,实际上 LaunchedEffect 的语义是“key 驱动的协程生命周期管理”,不是“每次重组后的回调”。把这个语义记错,会导致两类典型 bug:一是以为 effect 会重复执行而多加不必要的 key,二是 effect 该重启时没重启却毫无察觉。第 5 课会结合 DisposableEffect、SideEffect 做完整对照。


习题 11(概念辨析·判断题)——SideEffect 的触发时机

题目: 判断正误:SideEffect 在每次重组之前执行,适合用来做“重组前的准备工作”。

参考答案:错误。

解读: SideEffect 在每次成功重组之后、布局阶段开始之前执行,不是之前。它没有 key,也没有清理逻辑,适合“把 Compose 状态发布给非 Compose 对象”这类每次重组都需要同步一次的操作。它不是“准备工作”工具;需要“进入组合时执行一次”的场景应该用 LaunchedEffect 或 DisposableEffect。本题针对的是把 SideEffect 当成“生命周期钩子”的常见误用。


习题 12(代码分析·rememberUpdatedState)——长期 effect 捕获旧引用

题目: 以下代码中,如果父级传入了一个新的 onTimeout,但 notification 没有变化,LaunchedEffect 内部调用的是新 onTimeout 还是旧 onTimeout?请说明原因并给出修复。

@Composable
fun NotificationHost(
    notification: Notification?,
    onTimeout: (Notification) -> Unit
) {
    notification?.let { n ->
        LaunchedEffect(n) {
            delay(5000)
            onTimeout(n)
        }
    }
}

参考答案:

调用的是旧 onTimeout。

原因:LaunchedEffect(n) 的 key 是 n。n 不变时 effect 不重启,协程内部持有的是 effect 首次启动时捕获的 onTimeout 引用。父级后来传入的新 lambda 不会自动更新到已存活的协程中。

修复:

val currentOnTimeout by rememberUpdatedState(onTimeout)

LaunchedEffect(n) {
    delay(5000)
    currentOnTimeout(n)  // 始终读取最新值
}

解读: 本题考察“长期存活的 effect 捕获旧引用”这一结构性风险。判断规则是:只要 effect 的存活时间可能长于当前组合,而它内部又引用了组合期间计算的参数或 lambda,就要检查是否需要 rememberUpdatedState。注意 rememberUpdatedState 不会重启 effect,它只是提供一个引用稳定的 State 容器,让 effect 读取到最新值。第 3 课会从 remember 的边界角度再讲一次。


习题 13(场景判断·指标与结论)——重组计数能证明性能提升吗

题目: 你用 Layout Inspector 发现某可组合项在一次滚动中重组了 80 次,优化后降到 8 次。同事说“性能提升了 10 倍”。这个结论是否严谨?请说明理由,并给出更严谨的验证方式。

参考答案:

不严谨。 重组次数下降只说明组合阶段的执行次数减少,不能直接推导出整体性能提升 10 倍。原因包括:

  1. 跳过本身有成本:槽表遍历、参数比较、组边界检查都需要时间;重组次数少不代表总耗时按比例下降。
  2. 每次重组的成本不同:80 次轻量重组的总耗时可能小于 8 次重量级重组。
  3. 瓶颈可能不在组合阶段:如果真正瓶颈在布局、绘制或主线程外的其他工作,减少重组对帧时间影响有限。
  4. 可能引入新开销:为减少重组而引入的逐元素 equals() 比较,在大列表上可能成为新热点。

更严谨的验证方式: 使用组合跟踪(composition tracing)观察组合阶段耗时占比,用 Macrobenchmark 测量真实帧时序(如 FrameTimingMetric)和 CPU 影响,结合 Perfetto 查看主线程各阶段分布。重组计数是诊断信号,不是性能结论。

解读: 本题针对第五部分“重组计数陷阱”。在团队协作中,“重组次数降了 10 倍”是一句很有迷惑性的话,容易让优化停留在表面指标。第 18 课会系统讲工具链,但第 1 课就要建立“指标 ≠ 结论”的判断习惯。


习题 14(概念辨析·选择题)——副作用 API 的选择

题目: 你需要在一个可组合项进入组合时注册传感器监听器,并在离开组合时注销它。最合适的 API 是:

A. LaunchedEffect(Unit) B. SideEffect C. DisposableEffect(Unit) D. remember { SensorListener() }

参考答案:C

解读: DisposableEffect 的核心特征是强制成对书写注册与清理:进入组合时执行注册,离开组合时执行 onDispose 中的注销,key 变化时先 dispose 再重新注册。这正是资源管理的语义需求。A 虽然也能在协程里注册,但缺少结构化的清理协议,容易漏注销;B 每次重组都执行且无清理;D 只创建对象,不处理生命周期注册与注销。第 5 课会展开三者组合使用的完整模式。


习题 15(综合应用·判断框架)——用五问审查一段真实风格代码

题目: 请用本课第六部分的五个判断问题(阶段、跳过、身份、副作用、诊断),审查下面这段代码,指出至少 3 个潜在问题并说明理由。

@Composable
fun ChatScreen(messages: List<Message>, onSend: (String) -> Unit) {
    var input by remember { mutableStateOf("") }
    val visible = messages.filter { it.visible }
    LazyColumn {
        items(visible.size) { index ->
            MessageRow(visible[index])
        }
    }
    LaunchedEffect(Unit) {
        scrollToBottom()
        onSend(input)
    }
}

参考答案(至少 3 点,答对即可):

  1. 跳过问题:messages.filter { ... } 每次重组创建新 List,visible 作为不稳定参数参与 === 比较永远失败;同时过滤计算在组合阶段重复执行。建议 remember(messages) 缓存或上移到状态层。

  2. 身份问题:items(visible.size) 使用下标作为隐式身份,MessageRow 没有业务 key。消息列表插入、删除、重排时会导致 remember 状态错位和动画错位。应改为 items(visible, key = { it.id })。

  3. 副作用问题:LaunchedEffect(Unit) 只执行一次,但内部读取了 input 和 onSend。input 后续变化不会触发 effect 重启,onSend 也可能是旧引用。如果意图是“发送时读取最新输入”,应使用 rememberUpdatedState 或将发送逻辑改为事件驱动(在点击回调中启动协程),而不是放在 LaunchedEffect(Unit) 里。另外 scrollToBottom() 放在 Unit key 下只执行一次,新消息到达时不会再次滚动,语义可疑。

  4. 阶段问题(可加分) :input 在组合阶段被读取并用于 effect 捕获,若 input 变化频繁,需评估是否应将读取推迟或改用事件回调。

解读: 本题是本课的“综合演练”,把阶段、跳过、身份、副作用四条线索放进一段真实风格的代码里。能答出 3 点说明已经建立了可推理的心智模型;能指出第 3 点中“LaunchedEffect(Unit) 捕获旧 input”与“滚动只执行一次”两个独立问题,说明对副作用生命周期的理解已经到位。第 2 课会用编译器报告验证第 1、2 点的稳定性判断,第 3 课会深入第 3 点的 rememberUpdatedState 模式。


第八部分:本课知识点总结

一、概念地图:四个核心概念的关系

本课讲的所有内容,可以压缩成一张关系图:

状态变化
   │
   ▼
【读取即订阅】── 谁读了状态,谁就被标记为 invalid
   │
   ▼
【阶段归属】── 读取发生在组合/布局/绘制,决定哪一阶段重新执行
   │
   ▼
【重组】── 组合阶段重新执行受影响的作用域
   │
   ▼
【跳过】── 参数稳定的可组合项可以复用上一轮结果
   │
   ├── 稳定性:稳定参数 equals(),不稳定参数 ===
   ├── 强跳过:放宽连坐,但不改变新实例导致引用变化
   └── 身份:key 决定"是不是同一个",身份错了跳过无从谈起
   │
   ▼
【副作用】── 依附于组合生命周期,不依附于重组次数
   ├── LaunchedEffect:key 驱动协程生命周期
   ├── DisposableEffect:强制成对注册/清理
   ├── SideEffect:每次重组后、布局前执行
   └── rememberUpdatedState:解耦 effect 存活与值更新

二、一帧的三道工序

阶段做什么产出
组合(Composition)执行 @Composable 函数界面说明树(composition),由槽表承载
布局(Layout)测量与放置每个元素的大小和坐标
绘制(Drawing)落像素屏幕上的画面

顺序固定:组合 → 布局 → 绘制。重组只发生在组合阶段,它是“重新组合”,不是“重新渲染”。少数场景(BoxWithConstraints、LazyColumn、SubcomposeLayout)会出现子级组合依赖父级布局的逆向时序,这是有意为之的例外,不是默认路径。

三、状态读取即订阅

  • 在组合阶段读取状态 → 该作用域订阅该状态 → 状态变化触发重组。
  • 在布局阶段读取状态(如 Modifier.offset { })→ 变化只触发重新布局。
  • 在绘制阶段读取状态(如 Modifier.drawBehind { })→ 变化只触发重绘。
  • 订阅精确到重组作用域,不是精确到组件。重组的边界由“谁读了状态”决定,不由“状态声明在哪里”决定。
  • 想缩小重组范围,就去缩小读取范围。

四、跳过与稳定性

  • 跳过是 Compose 性能模型的地基:参数无变化时复用上一轮组合结果。
  • 稳定参数用 equals() 比较;不稳定参数用 === 比较。
  • 稳定来源:不可变(全 val 且字段类型稳定),或显式 @Stable / @Immutable 承诺。
  • List / Set / Map 及含 var 字段的 data class 默认不稳定。
  • 稳定性推断有模块边界:跨模块类型可能被保守标记为不稳定。
  • 强跳过模式(Kotlin 2.0.20 起默认):所有可重启可组合项均可跳过;不稳定参数用 ===;lambda 自动记忆化。但它没有把 List 变稳定,也没有消除“新实例导致引用变化”的约束。
  • 跳过是编译器生成的组级操作($changed 参数 + skipToGroupEnd()),取决于参数类型,不取决于函数体逻辑。

五、身份与 key

  • 默认身份由位置决定;动态列表中位置身份会导致 remember 状态错位。
  • key 把身份从位置切换为业务唯一标识。
  • 列表 key 必须用业务唯一标识;index 仅适用于永不删除/重排的静态列表;随机 UUID 等于每帧重建。
  • key 影响的不只是状态,还有 animateItemPlacement、复用池、rememberSaveable。
  • 先保身份正确(正确性),再谈跳过优化(性能)。

六、副作用

API触发时机key 变化离开组合典型用途
LaunchedEffect(key)进入组合 / key 变化取消旧协程,启动新协程取消协程挂起操作、一次性事件
DisposableEffect(key)进入组合 / key 变化先 dispose 再注册执行 dispose注册/注销监听器、资源绑定
SideEffect每次成功重组之后、布局之前不适用(无 key)无向非 Compose 代码发布状态
  • 副作用生命周期跟随组合,不跟随“函数被调用次数”。
  • LaunchedEffect 的 key 不变,宿主重组也不重启。
  • 副作用有明确的帧内时序位置,决定了它们能读到什么、不能读到什么。
  • 长期存活的 effect 若引用组合期间计算的 lambda/参数,用 rememberUpdatedState 解耦“存活”与“更新”。

七、高频反模式速查表

反模式症状根因修复方向
组合函数体里 filter / 排序 / 格式化重组次数多、卡顿组合阶段重复计算 + 新实例导致跳过失效remember(keys) 缓存或上移状态层
每次重组分配新集合/lambda子项无法跳过不稳定参数 === 比较失败稳定实例、强跳过(lambda)、状态派生
混淆 Modifier 的 lambda 与非 lambda 版本不必要重组状态读取阶段错误按“影响哪道工序”选择阶段
列表用 index 或随机值作 key状态错位、动画飞错行位置身份与业务身份不对应业务唯一标识作 key
LaunchedEffect(Unit) 当“每次重组回调”捕获旧值、该重启不重启误解 effect 生命周期事件驱动或 rememberUpdatedState
重组计数当性能结论优化方向错误指标 ≠ 结论组合跟踪 + Macrobenchmark

八、代码审查五问

  1. 阶段:这个状态是在组合阶段读的,还是布局/绘制阶段读的?
  2. 跳过:参数里有没有每轮新建的集合、lambda、可变实例?稳定性是否经编译器报告验证?
  3. 身份:列表 key 是不是业务唯一标识?条件分支是否需要 key?
  4. 副作用:effect 存活时间是否长于当前组合?是否需要 rememberUpdatedState?清理与注册是否对称?
  5. 诊断:我是用重组计数判断,还是用组合跟踪 + 基准测试确认了真实影响?

九、通向第 2 课的接口

本课建立了判断框架,但“参数到底稳不稳定”“这个可组合项到底能不能跳过”不能靠猜。第 2 课将进入稳定性深水区:

  • @Stable 与 @Immutable 的契约差异与适用边界;
  • 编译器稳定性推断的完整规则与模块边界;
  • 集合类型的稳定性困境与 ImmutableList / kotlinx.collections.immutable 的真实代价;
  • 用 Compose 编译器报告和反编译证明跳过能力,而不是“看起来应该能”。

第 1 课给了你推理模型,第 2 课给你验证工具。我们下一课见。