摘要
本文从一次“卡顿修好了、界面却不更新”的真实 bug 切入,把 Compose 稳定性从模糊感觉变成可推断、可证明、也可被伪造的事实。全文依次拆解:稳定性的两种信任来源与四条推断规则、递归传递性、@Stable与@Immutable的承诺差异及编译器等价性、用classes.txt/composables.txt/ 反编译定位根因、强跳过模式取消连坐后带来的新比较成本、List与ImmutableList的三场景决策、跨模块边界与stability_config.conf,最后完整追踪案例修复并给出 15 道习题与速查表。
核心原则只有一句:先验证,再优化;注解不是开关,是合同。
版本提醒:文中涉及$changed、$stable、强跳过默认开启版本等编译器实现细节,均应以项目实际使用的 Compose Compiler / Kotlin 版本为准。
目录
- 前言
- 一、开场:修好了卡顿,却引入更隐蔽的 bug
- 二、稳定性是什么:Compose 敢不敢跳过你
- 三、注解是合同,不是开关
- 四、怎么证明:读编译器报告与字节码
- 五、强跳过:取消连坐,但换了账本
- 六、集合:
List和ImmutableList是两种成本结构 - 七、跨模块边界:为什么 domain 的 val class 也报不稳定
- 八、完整案例追踪:从 bug 到修复
- 九、15 道习题(精简版)
- 十、总结速查
- 十一、通向第 3 课
前言
如果你写过 Compose,大概遇到过这样的时刻:数据改了,界面却像没听见一样纹丝不动。没有崩溃、没有报错、日志正常,但用户看到的是旧内容。这类问题十有八九和“稳定性”有关。
但“稳定性”很容易被讲玄。有人告诉你“加个 @Immutable 就好了”,你加了,卡顿确实缓解;过两周,一个更隐蔽的 bug 冒出来,你才发现自己埋了雷。问题不在注解本身,而在于我们常把它当成“开关”,而不是“合同”。
本文想做的,是把稳定性从模糊感觉变成可推断、可证明、也可被伪造的事实。出发前先记住三句话:
- 稳定性首先是编译器递归推断出来的事实,不是注解给人的感觉。
- 注解是覆盖推断的合同,不是让编译器闭嘴的开关。
- 强跳过后,比较成本结构变了:
List常走 O(1) 的===,而ImmutableList比较不同实例时可能是 O(N) 的equals()。
一、开场:修好了卡顿,却引入更隐蔽的 bug
列表页滚动卡顿,MessageRow 在一次滚动中重组上百次。你搜到一条建议:“给数据类加 @Immutable,Compose 就能跳过重组。”于是你写了:
@Immutable
data class Message(
val id: String,
val content: String,
var isRead: Boolean // 注意这个 var
)
重组次数确实降了,卡顿缓解。两周后 bug 来了:消息已读状态更新了,但界面小红点没消失。
原因是某处代码直接执行 message.isRead = true,没有通过 Compose 的 State 系统通知界面。更糟的是,@Immutable 让编译器把 Message 当成稳定类型,参数比较走 equals()。改的是同一个对象,equals() 仍返回 true,于是 MessageRow 被跳过。
没有崩溃,没有警告,只有一句最危险的话:状态更新了,界面没变。
还要注意:在强跳过模式下,仅仅去掉 @Immutable 也不一定修得好。因为 Message 变回不稳定后,参数改用 === 比较;同一个实例原地修改,=== 仍然是 true,仍可能被跳过。
所以真正的根因不是“注解本身”,而是:可变状态没有通过 Compose 能观察到的方式传播。 @Immutable 只是让错误发生在 equals() 层,使问题更隐蔽。
二、稳定性是什么:Compose 敢不敢跳过你
1. 稳定性在优化链中的位置
稳定性回答的问题是:这个参数,Compose 敢不敢用 equals() 比较、比较完之后敢不敢跳过? 但它不回答另外几个问题:比较本身贵不贵,跳过省下来的时间值不值得,以及重组是否本来就可以通过相位延迟避开。
一个在组合阶段读取了快速变化状态的 composable,即使所有参数都稳定、每次都被正确跳过,父级仍然会因为那次状态读取而重组。子级跳过只是止损,不是根治。官方把“将快速变化的状态读取推迟到布局或绘制阶段”列为与稳定性并列的独立优化手段。稳定性解决“参数比较能不能短路”,相位延迟解决“这次重组本来该不该发生”。
文字化决策路径:
- 状态变化后,先问:这次重组本来能否通过相位延迟避免?
- 若不能避免,进入重组,再看参数能否用
equals()比较。 - 稳定参数:
equals()相等则跳过。 - 不稳定参数:强跳过下用
===比较;命中则跳过,未命中则重组。
下面这张图把「这次重组该不该发生」和「参数能不能跳过」两条判断串起来:
2. 两种信任
Compose 对稳定类型的定义,翻成大白话:
如果一个类型不可变,或者 Compose 能知道它的值在重组之间有没有变,它就是稳定的。
第一种:不会变。 所有属性都是 val,属性类型本身稳定,公开方法没有副作用。对象创建后,可观察状态固定,Compose 可以放心用 equals() 比较。
第二种:会变,但变化能被通知。 类型内部可能可变,但变化通过 mutableStateOf 等 Compose 能观察到的方式传播。
关键区别:第一种通常能自动推断;第二种通常需要显式注解。
3. 四条推断规则
- 规则一:基本类型和
String稳定。Int、Long、Float、Double、Boolean、Char、String是推断原子。 - 规则二:函数类型作为参数类型稳定。 但函数类型稳定,不等于 lambda 实例引用稳定。lambda 引用稳定性由强跳过单独处理。
- 规则三:所有属性都是
val,且属性类型都稳定的类,被推断为稳定。 - 规则四:包含不稳定字段的类,被推断为不稳定。 一个不稳定字段足以拖垮整个类。
背后还有一条常被忽略的规则:稳定性递归传递。
data class Address(val city: String, val street: String) // 稳定
data class User(val name: String, val address: Address) // 稳定
data class Order(val user: User, val items: List<Item>) // 不稳定:List 不稳定
Order 不稳定,不是 Order 本身有问题,而是 items: List<Item> 不稳定。不稳定性会沿字段链向上传播。
四条规则加上递归传递,可以画成一条自底向上的推断链:
4. 一个反常识:Compose 模块内的 val data class 本来就稳定
不是必须加 @Immutable 才能让 data class 稳定。在启用 Compose 编译器的模块中,一个所有属性都是 val、属性类型本身稳定的扁平 data class,已经被自动推断为稳定,参数比较自动走 equals()。官方明确说明:Compose 模块内带稳定属性的类已经是稳定的,不需要 @Immutable 或 @Stable。
注解真正有意义的场景只有三类:
- 类型定义在未启用 Compose 编译器的模块中;
- 类型包含集合字段,导致整体不稳定;
- 你确实需要覆盖编译器推断,并愿意为合同负责。
给本来已稳定的 val data class 加 @Immutable,是最常见的无效优化。
5. 稳定、不稳定、未知:三种状态
编译器分析有三种结果:稳定、不稳定、未知。当字段类型来自未启用 Compose 编译器的模块或某些 Java 类型时,编译器无法分析,会保守标记为不稳定,但内部原因是“未知”。
排查时要区分:
- 确定不稳定:字段类型确实不稳定,如
List。对策是改数据模型或换集合类型; - 未知:字段来自外部模块,编译器无法分析。对策是处理模块边界。
两者对策完全不同。
三、注解是合同,不是开关
1. @Immutable:强承诺,高风险
@Immutable 的承诺是:这个类型不可变。构造完成后,可观察状态永不改变。
风险在于:注解不改变代码行为,只改变编译器对待你的方式。给含 var 的类加 @Immutable,编译器会当稳定类型,用 equals() 比较,相等时跳过重组。如果对象实际偷偷变了而 equals() 没反映,Compose 就会跳过一次本应发生的重组——界面停留在旧状态,无报错。
使用硬条件:你必须能证明该类型构造后不再发生可观察变化。不能证明,不要用。
2. @Stable:承诺靠什么兑现
@Stable 的承诺是:类型可能可变,但变化会通过 Compose 能观察到的方式传播。
这里要补上关键一层:“Compose 能观察到”的物理含义是什么? 答案是快照系统。mutableStateOf 创建的状态对象在值被修改时,会通知快照系统该状态已失效,从而触发依赖它的组合作用域重新执行。换句话说,变化之所以能被观察到,是因为值的变化发生在一个 Compose 注册了监听的状态对象上。
这直接解释了为什么下面这种写法是空的:
@Stable
class FormState {
var text: String = "" // 裸 var,Compose 观察不到
var isValid: Boolean = false
}
编译通过,报告显示 stable,但变化传播的合同没有运行时基础设施兑现。正确形态是:
@Stable
class FormState {
var text by mutableStateOf("")
var isValid by mutableStateOf(false)
}
@Stable 允许类型内部可变,但那个“可变”必须是快照系统管理的可变。裸 var 加 @Stable,与 @Immutable 的静默跳过 bug 没有本质区别,只是入口不同:@Immutable 让 equals() 掩盖变化,@Stable 让编译器以为你会通知、但你没有。
3. 编译器层面:两者对跳过协议效果相同
在跳过协议上,@Stable 和 @Immutable 效果相同:都让编译器把类型标记为稳定,并用 Object.equals() 比较参数。区别只在承诺语义:@Immutable 承诺“不会变”,@Stable 承诺“变了我负责通知”。
选择依据是类型真实行为,不是“哪个让编译器更高兴”。
4. 什么时候才应主动加注解
第一步:先别加。 Compose 模块内、全 val、字段类型稳定的类型已经稳定,注解是噪声。
第二步:报告说不稳定,先看原因。 最常见是集合字段或模块边界。
第三步:只有类型在非 Compose 模块,或确需覆盖推断,且 equals() 成本足够低,才考虑注解。 官方措辞是 “Only annotate classes with cheap .equals() checks”。包含大列表的类,equals() 是 O(N),加注解可能从“引用比较跳过”变成“逐元素比较再决定”,反而更贵。
四、怎么证明:读编译器报告与字节码
推断是假设,证明是事实。
1. 生成报告
composeCompiler {
reportsDestination = layout.buildDirectory.dir("compose_compiler")
metricsDestination = layout.buildDirectory.dir("compose_compiler")
}
构建后输出 classes.txt(类稳定性)、composables.txt(可组合项可重启/可跳过)和 CSV 版本。
2. 读 classes.txt:五步定位不稳定根因
- 搜索
unstable class,列出问题清单。 - 对每个不稳定类看字段列表。
unstable class Order {
stable val id: String
unstable val items: List<OrderItem>
stable val total: Long
}
结论:Order 不稳定,因为 items: List<OrderItem> 不稳定。
- 判断原因类型。 字段类型确定不稳定(
List、含var的类)→ 改字段类型或数据模型;字段来自外部模块 → 处理模块边界;字段是未加注解的可变类 → 审计该类型。 - 决定修复方向。 集合字段不要急着给外层类加
@Immutable,先问属于集合三场景中的哪一个。 - 修复后重新生成报告,确认
unstable消失或原因改变。
3. 读 composables.txt:四步定位跳过失效
- 搜索缺少
skippable的restartable函数,这些是潜在性能热点。 - 看签名里标为
unstable的参数,这是跳过失效的直接原因。 - 回到
classes.txt查该参数类型的稳定性来源。 - 判断是否真的值得修复。 不是所有不可跳过都是问题。若可组合项很轻,不跳过可能比“O(N) 比较后跳过”更划算。
4. 反编译:报告回答不了的问题,字节码回答
编译器报告告诉你“谁不稳定”,但不告诉你“稳定性在字节码里长什么样”。当报告与预期冲突,或者你想确认跳过逻辑是否真的生成时,反编译是裁决手段。注意:以下字节码细节属于编译器实现,不同版本可能变化,应以实际反编译结果为准。
- 看
$changed的位布局。 Compose 编译器为每个可组合函数注入$changed参数。常见实现中,每个参数占若干 bit,并用状态枚举区分Uncertain、Same、Different、Static、Unknown等;其中Unknown相关位可反映参数类型在编译期的稳定性判定。旧版本布局可能不同,不要把它当跨版本常量。 - 看跳过分支。 搜索
skipToGroupEnd()。没有它,函数通常不可跳过;有它,再看守卫条件里$dirty的位掩码,可以反推编译器在调用点已经确定了几个参数的状态。 - 看
$stable字段。 对目标类执行javap -p,查找合成的$stable静态字段。它用于编码稳定性标记,具体值以实际编译器版本为准。它是比编译器报告更底层的物证,但同样要加版本限定。
5. 泛型与内联类的稳定性
四条推断规则没有覆盖泛型,但 Result<T>、State<T> 在实际代码中无处不在。
编译器对泛型类的稳定性处理不是简单布尔值,而是一组按类型参数索引的位。@StabilityInferred(parameters = Int) 的 parameters 是一个位掩码,每个类型参数占一位;某一位为 1,表示该类的稳定性需要结合那个位置的实际类型参数来判断。例如 class X<T>(val p1: List<T>) 只有 T 影响稳定性时,对应位会体现这种依赖;换成不稳定类型参数,稳定性判断也会变化。
内联类(value class)有专门的判断路径:如果内联类自身带 @Stable,直接稳定;否则拆解到它的底层类型再做分析。value class UserId(val value: Int) 拆到 Int,稳定;value class Token(val value: String) 拆到 String,稳定;但如果底层类型不稳定且没有注解,内联类本身也不稳定。
6. 工具四件套,以及一个硬前提
| 工具 | 回答什么问题 | 使用时机 |
|---|---|---|
| 编译器报告 | 静态:谁不稳定?哪个字段拖累?谁不可跳过? | 第一步,定位 |
| 反编译 | 字节码:$changed 位布局、skipToGroupEnd()、$stable 值 | 报告与预期冲突时裁决 |
| Layout Inspector | 运行时:实际重组/跳过次数? | 确认静态问题是否造成运行时影响 |
| Macrobenchmark | 性能:帧时序和 CPU 影响是否改善? | 最后一步,验证收益 |
以上所有性能结论,必须在 release 构建 + R8 开启 的前提下得出。官方明确警告:绝不要在 debuggable 构建上做性能分析或基准测试,ART 的运行时校验会严重扭曲性能数据。debug 构建的重组计数和帧时序不作为优化依据。重组计数是诊断信号,Macrobenchmark 的帧时序才是结论。
五、强跳过:取消连坐,但换了账本
强跳过模式在较新的 Compose Compiler 中已默认启用;更早版本需要在 composeCompiler 块中显式设置 enableStrongSkippingMode = true。具体默认版本以项目使用的 Compose Compiler / Kotlin 组合为准。
1. 两项行为变更
第一,所有可重启的可组合函数都变为可跳过,无论参数是否稳定。 旧模式下,一个不稳定参数会让整个可组合项失去跳过资格。强跳过取消连坐:不稳定参数仍存在,但改用 === 参与比较。不可重启的函数仍然不可跳过。
第二,带不稳定捕获的 lambda 被自动 remember。 旧模式下每次重组创建新 lambda 实例,=== 永远失败;强跳过用 remember 包裹,捕获不变则引用稳定。
2. 比较协议
| 参数类型 | 比较方式 | 强跳过前 | 强跳过后 |
|---|---|---|---|
| 稳定参数 | Object.equals() | 可参与跳过比较 | 可参与跳过比较 |
| 不稳定参数 | === 引用相等 | 导致整个可组合项不可跳过 | 可参与比较,但 === 失败则不跳过 |
| 带不稳定捕获的 lambda | ===(经自动记忆化) | 每次新实例,=== 失败 | 捕获不变则引用稳定,=== 可通过 |
常见困惑:“为什么强跳过启用了,我的可组合项还是没跳过?”答案几乎总在第二行:不稳定参数用 === 比较,而你每次重组都在创建新实例。 强跳过给了它参与比较的资格,但没有改变“新实例引用不同”的物理事实。
文字化比较路径:
- 函数是否可重启?否 → 不可跳过,直接执行。
- 是 → 强跳过是否启用?否 → 若存在不稳定参数,则不可跳过;否则全部参数走
equals()。 - 强跳过启用 → 稳定参数走
equals(),不稳定参数走===。 - 全部比较命中 → 跳过重组;否则执行重组。
把比较协议画成判定流程,更容易看清「为什么强跳过启用了还是没跳过」:
3. 新代价:为什么 ImmutableList 可能反而更慢
官方明确警告:强跳过下,标准 List 使用 === 跳过,而 ImmutableList 和加了稳定注解的集合模型在每一轮重组中执行逐元素 .equals() 比较;对于大型集合或懒加载布局,这可能比重组本身更耗时。
精确地说:List 作为不稳定参数走 O(1) 的 ===;ImmutableList 作为稳定参数走 equals(),比较不同实例时可能退化为 O(N)。若比较比重组还贵,优化就变成负优化。
4. @NonSkippableComposable:主动选择不跳过
有些场景你不希望可组合项被跳过:函数体里有无法用 remember 或状态系统表达的副作用,或者它的执行本身就是“信号”。@NonSkippableComposable 声明一个可重启但不可跳过的可组合函数,服务于语义正确性,不是性能调优。
六、集合:List 和 ImmutableList 是两种成本结构
1. 为什么 List 永远不稳定
List、Set、Map 是接口,编译器无法确认运行时实现是否真正不可变。listOf(...) 可能返回 ArrayList 的只读视图,MutableList 也实现 List 接口。硬规则:始终标记为不稳定。
2. 三场景决策
| 场景 | List 行为 | ImmutableList 行为 | 建议 |
|---|---|---|---|
| 实例从不变化 | === 直接命中 | equals() 可快速短路 + 一次性转换成本 | 用 List |
| 内容变才实例变 | === 失败,重组 | 不同实例时可能 O(N) equals() + 转换成本 | 用 List,转 ImmutableList 通常负优化 |
| 内容不变但实例频繁重建 | === 失败,不跳过 | equals() 可识别内容相同,可能在更高层跳过 | 可考虑 ImmutableList,需验证成本 |
“实例从不变化”场景中,ImmutableList 作为稳定参数走的是 equals(),只是同一实例通常快速短路,成本接近 ===。结论仍然是 List 更干净。
核心结论:ImmutableList 不是“更稳定的 List”,而是一种不同的成本结构。 强跳过前它是“让不稳定变稳定”的工具;强跳过后它是“用结构比较换取更高层跳过机会”的工具。
决策路径:
- 实例是否频繁重建?从不重建 → 用
List,===直接命中。 - 频繁重建 → 内容是否变化?内容变才实例变 → 用
List,===失败即重组,成本最低。 - 内容不变但实例重建 →
equals()成本可接受吗?可接受 → 可考虑ImmutableList;不可接受或嵌套深 → 仍用List,或上移缓存。 - 任何选择都用 Macrobenchmark 验证收益。
三场景决策可以收敛成下面这棵树:
3. 嵌套成本放大
@Immutable
data class Feed(val items: ImmutableList<FeedItem>)
比较不同实例时:Feed.equals() 逐字段比较 → items.equals() 逐元素比较 → 每个 FeedItem.equals() 再比较。若 FeedItem 也含集合,成本进一步叠加。嵌套集合是稳定性成本黑洞。
七、跨模块边界:为什么 domain 的 val class 也报不稳定
稳定性推断有模块边界。若字段类型定义在未启用 Compose 编译器的模块中,UI 模块编译器只能看到字节码,无法确认字段类型是否稳定,可能保守标记为不稳定。
三种解决方案
- 在数据模块中应用 Compose 编译器。 编译器插件和运行时依赖是两回事,不会把 Compose 运行时引入数据层。最推荐。
- 在 UI 边界转换为 UI 专用模型。 代价是多一层映射和对象分配,但架构隔离更清晰。
- 使用
stability_config.conf。 适用于第三方库或 Java 类型。优先列精确类型,不要用大范围通配符。
必须理解边界:配置文件只改变编译器判断,不验证第三方类型的线程安全、可变性或通知机制。把它列入配置后,编译器不再追问它是否真的稳定。使用条件:已审计实现,确认满足稳定合同,并有审计记录。
八、完整案例追踪:从 bug 到修复
1. 定位
生成 classes.txt。若注解生效,报告显示 stable class Message;MessageRow 签名为 restartable skippable fun MessageRow(stable message: Message, ...)。可跳过,所以重组次数下降——但也是 bug 来源。
2. 行为分析
Message 被 @Immutable 标记为稳定,参数比较走 equals()。某处直接改 message.isRead = true,但 MessageRow 收到的是同一个实例引用。equals() 比较同一对象返回 true,Compose 认为“参数没变”,跳过 MessageRow。
根因有两层:
- 可变状态没有通过 Compose 可观察渠道传播,这是正确性根因;
@Immutable让编译器用equals()比较,掩盖了同一实例的原地变化,这是让 bug 更隐蔽的合同根因。
在强跳过下,仅移除 @Immutable 并不足以修复:Message 变回不稳定后参数改用 ===,同一实例原地修改时 === 仍为 true,仍可能跳过。
3. 正确修复
- 移除错误的
@Immutable。 撤销错误承诺,但不是完整修复。 - 把可变状态移到 Compose 能观察到的地方。 推荐把
isRead从Message移除,由状态层维护Set<String>或Map<String, Boolean>记录已读状态。Message保持纯不可变,MessageRow接收message和isRead两个参数。isRead变化时参数比较能正确检测。 - 重新生成报告并手动验证 “已读状态更新时小红点变化”。
修复路径:
现象:已读状态更新,小红点不消失 → 读 classes.txt:Message 被标记 stable → 分析:equals() 比较同一实例返回 true,跳过重组 → 移除错误的 @Immutable → 仅移除注解是否足够?否:强跳过下 === 仍为 true → 把 isRead 移到状态层 → Message 保持纯不可变,MessageRow 接收 message + isRead → 重新生成报告确认稳定性符合预期 → 手动验证已读状态变化时小红点同步更新。
整个修复过程可以串成一条链路:
4. 案例小结
稳定性优化分三层:
- 推断层:根据字段类型和模块边界推断稳定性;
- 证明层:用编译器报告、反编译、Layout Inspector 验证;
- 合同层:加注解覆盖推断时,必须证明合同真实成立,且
equals()成本可接受。
大多数稳定性 bug 发生在第三层:跳过前两层,直接加注解,然后以为问题解决了。
九、15 道习题(精简版)
习题 1: 在启用 Compose 编译器的模块中,哪个类型会被自动推断为稳定?
A. data class Feed(val items: List<FeedItem>) B. data class User(val name: String, val age: Int) C. data class Form(var text: String, val isValid: Boolean)
答案:B。 A 含 List,C 含 var,均不稳定。
习题 2: data class Order(val id: String, val user: User) 只要所有字段都是 val,就一定稳定。
答案:错误。 若 User 含 List 或 var,不稳定性会沿字段链传播。
习题 3: @Stable 与 @Immutable 在跳过协议上效果相同吗?
答案:相同。 都标记稳定、都用 equals() 比较;区别只在承诺语义。
习题 4: 给含 var 的类加 @Immutable,最可能的后果是?
答案: 编译通过,但运行时可能跳过本应发生的重组,导致界面不更新。
习题 5: 强跳过启用后,所有可组合函数都变得可跳过。
答案:错误。 只影响可重启函数;不可重启的仍不可跳过。
习题 6: val filtered = items.filter { ... }; ItemColumn(filtered),ItemColumn 仍无法跳过,为什么?
答案: 每次重组创建新 List,=== 永远失败。用 remember(items) 缓存或把过滤上移到状态层。
习题 7: 读 unstable class Order { unstable val items: List<OrderItem> },指出原因并判断属于“确定不稳定”还是“未知”。
答案: List 接口始终不稳定,属于确定不稳定。
习题 8: restartable fun Foo(...) 缺少 skippable 表示什么?
答案: 可重启但不可跳过;直接原因通常是不稳定参数。
习题 9: 哪种场景把 List 转成 ImmutableList 最可能净收益?
A. 内容变才实例变 B. 内容不变但实例频繁重建 C. 实例从不变化
答案:B。 equals() 可识别内容相同,可能在更高层跳过。
习题 10: @Immutable data class Feed(val items: ImmutableList<FeedItem>) 为什么可能是负优化?
答案: equals() 逐字段、逐元素比较,可能从 O(1) === 升级为结构比较;嵌套时成本放大。
习题 11: UI 模块报告 User 不稳定,但 User 在 :domain 模块且全 val。给出至少两种方案。
答案: 在 :domain 启用 Compose 编译器;或在 UI 边界转换为 UI 模型;stability_config.conf 是兜底选项。
习题 12: 第三方库 Money 无法修改源码,报告不稳定,哪种做法正确?
答案: 在 stability_config.conf 中精确列出,前提是已审计稳定合同。不要用通配符。
习题 13: 解释 @Immutable data class Message(... var isRead ...) 改 isRead 后小红点不消失的根因与修复。
答案: equals() 比较同一对象返回 true,Compose 跳过。修复:移除注解不是完整修复;必须把 isRead 移到状态层或改为 State<Boolean> 让变化可观察。
习题 14: 审查一段代码::domain 的 Order 含 List,UI 层 @Immutable data class OrderUiState(val orders: ImmutableList<Order>, ...),组合中 state.orders.filter { ... }。指出至少 3 个潜在问题。
答案要点: 注解可能把 O(1) 升级为 O(N);ImmutableList 在“内容变才实例变”场景可能是纯开销;Order 跨模块且含 List,稳定性存疑;filter 每次创建新 List,子项 === 失败;items(size) 缺少业务 key。
习题 15: 怀疑 FeedScreen 滚动卡顿与 FeedItem 稳定性有关,设计从“怀疑”到“证明”的流程。
答案: ①编译器报告定位谁不稳定、谁不可跳过;②Layout Inspector 确认运行时重组/跳过次数;③反编译查 $changed 和 skipToGroupEnd();④Macrobenchmark(release + R8)验证帧时序改善;⑤CI 集成报告检查或基准门禁防回归。
十、总结速查
稳定性推断
| 规则 | 内容 |
|---|---|
| 规则一 | 基本类型和 String 稳定 |
| 规则二 | 函数类型作为参数类型稳定 |
| 规则三 | 全 val 且字段类型稳定的类自动稳定 |
| 规则四 | 含不稳定字段的类不稳定 |
| 传递性 | 不稳定性沿字段链向上传播 |
| 泛型 | 稳定性按类型参数逐位判断(@StabilityInferred 位掩码) |
| 内联类 | 无 @Stable 时拆解到底层类型判断 |
核心事实:Compose 模块内的 val 扁平 data class 已自动稳定,加 @Immutable 是噪声。
@Stable 与 @Immutable
| 注解 | 承诺 | 编译器行为 | 运行时基础设施 |
|---|---|---|---|
@Immutable | 构造后永不变化 | 标记稳定,equals() 比较 | 不依赖快照系统 |
@Stable | 可变,但变化可观察 | 标记稳定,equals() 比较 | 依赖快照系统兑现通知 |
| 无注解 | — | 自动推断 | — |
两者在跳过协议上效果相同,区别在承诺语义和运行时兑现方式。@Stable 配裸 var 是空合同。
强跳过模式
- 较新 Compose Compiler 默认启用;更早版本需手动开启
enableStrongSkippingMode = true,以项目版本为准。 - 所有可重启函数可跳过;不稳定参数用
===,稳定参数用equals()。 - 带不稳定捕获的 lambda 自动
remember。 - 新代价:
ImmutableList比较不同实例时可能 O(N);标准List走 O(1)===。 @NonSkippableComposable服务于语义正确性,不是性能调优。
集合稳定性
| 场景 | List | ImmutableList | 建议 |
|---|---|---|---|
| 实例从不变化 | === 命中 | equals() 快速短路 + 转换成本 | List |
| 内容变才实例变 | === 失败 | O(N) equals() + 转换成本 | List,转 ImmutableList 通常负优化 |
| 内容不变但实例频繁重建 | === 失败 | equals() 可识别相同,可能更高层跳过 | 可考虑 ImmutableList,验证成本 |
嵌套集合放大 equals() 成本,是稳定性成本黑洞。
字节码层面的稳定性载体
以下均为版本敏感项,以实际反编译结果为准:
$changed:常见实现中每参数占若干 bit,Unknown相关位可反映类型稳定性判定。skipToGroupEnd():跳过分支的物理形态;没有它,通常不可跳过。$stable:类上的合成静态字段,用于编码稳定性标记;具体值随编译器版本变化。@StabilityInferred(parameters):位掩码按类型参数逐位编码稳定性依赖。
验证工具链
| 工具 | 回答什么 | 前提 |
|---|---|---|
| 编译器报告 | 谁不稳定、谁不可跳过 | 定位 |
| 反编译 | $changed 位、skipToGroupEnd、$stable | 裁决 |
| Layout Inspector | 实际重组/跳过次数 | 运行时确认 |
| Macrobenchmark | 帧时序和 CPU 是否改善 | release + R8,debug 数据不可信 |
代码审查三问
- 这个注解有必要吗? Compose 模块内的
val扁平 data class 已自动稳定,注解是噪声。 - 这个
ImmutableList是收益还是开销? 属于哪个场景?比较成本可接受吗?是否嵌套放大? - 这个跨模块类型真的不稳定吗? 报告说了什么?是模块边界还是类型本身?方案优先级是什么?
总决策路径:
遇到重组或界面不更新问题 → 先问:这次重组本来该不该发生 → 读编译器报告:谁不稳定、谁不可跳过 → 判断不稳定原因:集合字段按三场景选型,优先 List;模块边界则启用编译器 / UI 模型 / stability_config.conf;类型本身可变则把状态移到快照系统或改数据模型 → release + R8 下用 Macrobenchmark 验证 → 收益成立则固化到 CI 门禁,否则回退并重新评估成本结构。
十一、通向第 3 课
第 2 课解决了“稳定性怎么推断、怎么证明、怎么在字节码层面验证”。你现在能沿字段链判断稳定性;能按流程读报告和反编译;也能判断 ImmutableList 在具体场景里是优化还是负优化。
但还有一个与 remember 密切相关的问题没有展开:remember 的边界在哪里?
第 3 课要回答:remember 何时失效?key 怎么选?rememberSaveable 和 Saver 的边界在哪?rememberUpdatedState 如何解耦“effect 存活”和“值更新”?
第 2 课给了你指南针,第 3 课开始走具体的路。