【探秘 Jetpack Compose 框架深水区】第7课:Modifier 的边界在哪里?——阶段、延迟读取与状态在哪一层被消费

23 阅读35分钟

摘要:本课聚焦 Compose 中"状态在哪一层被读取"这一常被忽视的性能边界。文章先建立组合 → 布局 → 绘制的阶段模型,说明读取发生在哪一阶段,状态变化就只失效到哪一阶段;接着剖析 lambda modifier 如何把读取从组合阶段推迟到布局或绘制,从而跳过重组;再讨论无效化范围的真实边界——延迟读取是把失效挪到更便宜的阶段,而非消除失效;随后揭示"向后写入"这一方向约束,解释它为何会导致额外帧、首帧闪烁乃至无限重组循环;最后厘清 derivedStateOf(去重)与 lambda modifier(换层)的分工,并给出六问决策框架与 15 道习题。核心结论:读得晚,比读得少更根本;写错方向,比读错地方更危险。

目录

第6课把 derivedStateOf 定位为"读侧的状态过滤器":它解决的是"输入变化太频繁、但输出变化很少"的问题。但有一个更前置的代价问题,derivedStateOf 本身回答不了:同一个状态,如果在组合阶段被读取,它的每一次变化都会拖垮整棵重组作用域;如果推迟到布局或绘制阶段读取,同样的变化可能只需要重新放置或重绘。 Modifier.alpha(alpha) 和 Modifier.alpha { alpha } 只差一对花括号,失效范围却从"组合 + 布局 + 绘制"缩小到"绘制";Modifier.offset(x, y) 和 Modifier.offset { IntOffset(x, y) } 的差别,是"每次滚动都重组"和"每次滚动只重新放置"的差别。

这一课拆的就是这条边界:阶段如何决定读取的代价,lambda modifier 如何把读取安放到正确的阶段,以及当写入方向与阶段方向相反时,为什么会形成循环。


一、阶段模型:读取发生在哪一层,就失效到哪一层

Compose 执行一帧时,严格按照三个向前流动的阶段推进:组合运行 @Composable 函数,构建和更新 UI 树;布局测量子项,然后放置子项;绘制发出画布绘制命令,把像素渲染到屏幕上。

这三个阶段不是"每次都必须全部执行"的流水线。Compose 可以智能地跳过不需要的阶段:如果只是尺寸相同的两个图标切换,它可以跳过组合和布局,只重新绘制那个元素。但这套跳过机制有一个前提:它只对"读取点位于较晚阶段"的状态生效。 如果状态在组合阶段被读取,组合就无法被跳过,后续阶段自然也无法跳过。

阶段模型的运行规则只有一句话,但它的后果贯穿整课:在任意阶段读取一个 State,Compose 都会自动记录该状态与这个阶段之间的依赖关系。状态变化时,Compose 重新执行读取它的那个阶段,以及该阶段之后的所有阶段;它不会倒回去重跑更早的阶段。

由此得到三种完全不同的读取代价:

三种读取代价可以用一张图概括:

flowchart LR
  S["状态 State 变化"] --> C1["组合阶段读取"]
  S --> C2["布局阶段读取"]
  S --> C3["绘制阶段读取"]
  C1 --> R1["重新组合 → 布局 → 绘制"]
  C2 --> R2["跳过组合 → 重新布局 → 绘制"]
  C3 --> R3["跳过组合与布局 → 只重新绘制"]

在组合阶段读取:状态变化 → 重新组合 → 布局 → 绘制。失效范围是"最近的非 inline 重组作用域"整棵子树,并且级联到后续两个阶段。

在布局阶段读取(Modifier.offset { }、Modifier.layout { }):状态变化 → 跳过组合,只重新布局和绘制。这里需要区分布局的两个子步骤:测量(决定每个节点多大)和放置(决定每个节点在哪)。Modifier.layout { } 的 lambda 在测量子步骤中执行,可以读取并影响尺寸约束;Modifier.offset { } 的 lambda 在放置子步骤中执行,只影响位置、不影响尺寸。读取发生在放置子步骤时,如果状态变化只改变偏移量而不改变尺寸,甚至可以跳过测量,只重新放置。

在绘制阶段读取(Modifier.graphicsLayer { }、Modifier.drawBehind { }):状态变化 → 跳过组合和布局,只重新绘制。graphicsLayer 更进一步:它把内容提升为一个独立的渲染层(Android 上是 RenderNode,Skia 后端上是类似的图层机制),alpha、旋转、缩放、平移这些属性直接更新图层属性,不触发内容重绘,只做合成。这是延迟读取里最强的形态。

官方把这条原则概括得很直接:尽可能延后读取状态;通过把状态读取移到子 Composable 或后续阶段,可以最小化重组,或者完全跳过组合阶段;实现方式是传递 lambda 函数而不是状态值,并在传入频繁变化的状态时优先使用基于 lambda 的修饰符。

但"延后"有一个方向约束,官方称为向后写入:状态在较晚的阶段被写入,而更早的阶段依赖它,会迫使 Compose 安排更早的阶段重新运行。阶段应该向前流动:组合更新状态,布局或绘制读取它,是合法的;布局或绘制写入状态,组合读取它,就是逆流。这条约束会在第四节展开。

一句话记住这一节的边界:状态的"值"没有变,变的是"在哪一层读它";在哪一层读,就决定了它的变化要拖垮多少工作。而写入的方向,必须和读取的方向同向。


二、延迟读取:lambda modifier 到底改变了什么

Modifier.offset(0.dp, y) 和 Modifier.offset { IntOffset(0, y.roundToPx()) } 的差别不在语法,在读取发生的时机。

非 lambda 版本在组合阶段就读取了 y 的值,把结果作为 Modifier 的参数传入。y 一变,读取它的组合作用域就失效,Composable 必须重组,产出新的 Modifier 对象,再重新布局、绘制。lambda 版本把 y 的读取推迟到布局的放置子步骤:组合阶段只传入一个 lambda,y 变化时组合完全不知道,也不需要重组;布局阶段在执行 offset 的放置逻辑时读取 y,只有布局(且只是放置)失效。

这里有一个容易忽略的细节:lambda 版本的 offset 接收的是 IntOffset(像素),而不是 Dp。这是因为 lambda 在布局阶段执行时,已经处于像素空间,roundToPx() 的转换也发生在布局阶段,而不是组合阶段。非 lambda 版本接收 Dp,转换发生在组合阶段的参数求值中。这个差异本身就是"读取点从组合后移到布局"的一个具体体现。

同样的分界适用于一整组常见修饰符。官方修饰符阶段细分的快速参考表列出了精确的对照:

组合阶段直接读取Lambda 延迟替代延迟到的阶段与子步骤
Modifier.offset(x, y)Modifier.offset { IntOffset(x, y) }布局(放置),跳过组合
Modifier.alpha(alpha)Modifier.graphicsLayer { this.alpha = alpha }绘制,跳过组合和布局
Modifier.rotate(degrees)Modifier.graphicsLayer { rotationZ = degrees }绘制,跳过组合和布局
Modifier.scale(scale)Modifier.graphicsLayer { scaleX = s; scaleY = s }绘制,跳过组合和布局
Modifier.background(color)Modifier.drawBehind { drawRect(color) }绘制,跳过组合和布局

这张表的关键不是"换了一个 API",而是"读取点从组合阶段后移到了布局或绘制的 lambda 内部"。

从读取点看,lambda modifier 的本质是把读取从组合阶段"下移":

flowchart TD
  A["Modifier.offset(x, y)"] --> A1["组合阶段读取 y"]
  A1 --> A2["y 变化 → 重组 → 重新布局 → 重绘"]
  B["Modifier.offset { IntOffset(x, y) }"] --> B1["组合阶段只传 lambda"]
  B1 --> B2["布局放置子步骤读取 y"]
  B2 --> B3["y 变化 → 跳过组合 → 只重新放置与绘制"]

但延迟读取有两条容易被忽略的边界。

第一条:它只在"值确实在后续阶段被读取"时才有收益。 如果你把一个 lambda provider 传给一个最终还是在组合阶段读取它的 Composable,lambda 只是多了一次对象分配,读取仍然发生在组合阶段,延迟没有发生。官方明确说:把 lambda provider 传下去,只在值于布局或绘制阶段被读取时才有收益;如果在组合阶段读取,直接传原始值更合适,以避免 lambda 分配开销。典型反例是 Modifier.offset { } 内部读了状态,但同一个 Composable 又在组合阶段直接读了同一个状态——那部分读取仍然会触发重组,lambda 的收益被抵消。

第二条:延迟读取不是"消除失效",而是"把失效挪到更便宜的阶段"。 布局失效仍然要重新测量和放置,绘制失效仍然要重新发出绘制命令。它改变的是"要不要拖垮组合",不是"要不要干活"。理解这一点,才不会把延迟读取当成免费的午餐。

第三条:lambda 参数与延迟读取是两件事,读取点才是边界。 把 size: Dp 改成 size: () -> Dp 是"传递 lambda 而不是值",但收益仍然取决于读取点在哪里:如果 size() 在 Composable 正文里被调用,读取仍在组合阶段;如果 size() 在 Modifier.layout { } 的测量 lambda 里被调用,读取才真正被推迟。官方 codelab 的 MyShape 案例正好演示了这一点:只把参数改成 lambda 还不够,必须把 size() 的调用移进 layout 的测量逻辑,动画帧才会从"每帧重组"变成"每帧只重新布局"。


三、无效化范围:为什么"在 Modifier 里读"不等于"只影响那个 Modifier"

一个常见的误解是:只要把状态读取放进 Modifier.offset { },它的变化就只会影响那个 Modifier。这不准确。状态读取的无效化范围,取决于读取发生在哪个阶段,以及该阶段重新执行时涉及多大的作用域。

在布局阶段读取状态,布局失效的范围是包含该 modifier 的布局节点及其必要的重新测量/放置路径。在绘制阶段读取状态,绘制失效的范围是该绘制节点或渲染层。相比组合阶段读取导致"最近的非 inline 重组作用域整体重新组合,并级联到布局和绘制",布局/绘制阶段的读取确实把失效范围压缩到了更小的阶段和更小的节点集合。但它不是"零成本":重新布局和重新绘制仍然要执行。

更根本的边界在读取点的分布。同一个状态可以同时在多个阶段被读取,每个读取点各自记录依赖。如果滚动状态既在组合阶段被读取(用于文本内容),又在 Modifier.offset { } 里被读取(用于偏移),那么它的变化仍然会触发重组——因为组合阶段的读取点存在。延迟读取保护的是它内部的那次读取,不是状态本身。要真正跳过组合,必须确保这个状态在组合阶段没有任何读取点,而不只是"某个读取点被延迟了"。

还有一个容易忽略的细节:组合阶段的读取会让"最近的非 inline 重组作用域"失效。Column、Row、Box 是 inline 函数,不创建独立的重组作用域;状态在它们内部被读取,失效的可能是外层更大的 Composable。把读取移进 lambda modifier,相当于把"组合阶段、大作用域"的失效,换成了"布局/绘制阶段、小节点"的失效,而不是"完全不影响任何东西"。

一句话记住这条边界:延迟读取不是消除失效,而是把失效从"最贵的阶段 + 可能很大的作用域"挪到"较便宜的单阶段 + 较小的节点集合"。同一个状态只要在组合阶段还有读取点,它的变化就仍然会触发重组。


四、向后写入:阶段模型的单向约束

阶段模型有一条不是"优化建议"而是"方向约束"的规则:状态应该沿阶段向前流动,不能逆流。

官方把逆流称为向后写入:状态在比读取它更晚的阶段(或同一组合传递中更靠后的下游作用域)被修改,从而迫使 Compose 安排更早的阶段重新运行。向后写入的后果分三类:

阶段方向与向后写入的关系可以这样理解:

flowchart LR
  subgraph F["合法:状态沿阶段向前流动"]
    F1["组合更新状态"] --> F2["布局读取状态"] --> F3["绘制读取状态"]
  end
  subgraph B["逆流:向后写入"]
    B1["布局或绘制写入状态"] --> B2["组合阶段依赖它"] --> B3["被迫重新组合"]
    B3 --> B4["额外帧 / 首帧闪烁 / 潜在无限循环"]
  end

额外的帧渲染和丢帧:连续帧中执行多余的重组传递,浪费 CPU 和 GPU 资源。

首帧正确性问题:如果组件需要向后写入才能确定最终尺寸或状态,首帧会用无效、默认或不稳定的数据渲染(比如零尺寸或错误偏移),第二帧才纠正,出现可见的布局跳动或闪烁。

无限重组循环:这是最严重的一类。如果状态变化改变布局尺寸,而布局尺寸又不断把新值写回状态,且每次写回的值都不相等,屏幕可能每帧都在重组,永远无法稳定。这里的关键条件是"每次写回的值都不相等":如果新值最终收敛到一个稳定值,循环会在若干帧后停止;只有值持续变化、无法收敛时,才会形成真正的无限循环。

最典型的向后写入发生在"组合读取,布局写入":

@Composable
fun BadAspectRatioImage(painter: Painter) {
    var calculatedHeight by remember { mutableStateOf(0.dp) }
    val density = LocalDensity.current
    Image(
        painter = painter,
        contentDescription = "Dynamic Image",
        modifier = Modifier
            .fillMaxWidth()
            .height(calculatedHeight)   // 组合阶段读取
            .onSizeChanged { size ->    // 布局阶段写入
                val widthDp = with(density) { size.width.toDp() }
                calculatedHeight = widthDp / (16f / 9f)
            }
    )
}

onSizeChanged 在布局测量完成后报告大小,此时组合已经用旧的 calculatedHeight 完成了这一帧。写入使刚刚完成的组合失效。如果新值在下一帧稳定下来,重组可能多跑一帧后停止;但如果宽度变化导致高度变化、高度变化又导致宽度变化,值可能持续振荡,形成无限帧循环。官方文档明确把"组合读取,布局写入(onSizeChanged、LayoutModifier)"列为不可接受的向后写入。

修复的方向不是"把写入藏起来",而是把计算整体移到布局阶段,让组合阶段不再依赖这个尺寸:

@Composable
fun GoodAspectRatioImage(painter: Painter, aspectRatio: Float = 16f / 9f) {
    Layout(content = { Image(painter, "Dynamic Image") }) { measurables, constraints ->
        val width = constraints.maxWidth
        val height = (width / aspectRatio).toInt()
        val placeable = measurables.first().measure(
            constraints.copy(minWidth = width, maxWidth = width,
                             minHeight = height, maxHeight = height)
        )
        layout(width, height) { placeable.placeRelative(0, 0) }
    }
}

Layout 的测量 lambda 直接在布局阶段完成宽高计算,组合阶段完全不读 calculatedHeight,没有向后写入,也没有首帧闪烁。

对称的失败模式是"组合读取,绘制写入"。比如在 Modifier.drawBehind { } 中向一个组合阶段读取的 State 写入新值:绘制使组合失效,组合重新执行后又进入绘制,绘制再次写入。同样,只有写入的值持续变化、无法收敛时,才会形成无限循环。

但有一个重要的区分:事件回调(onClick、onValueChange)不算向后写入,因为它们在帧外执行,不处于组合、布局、绘制的阶段顺序之中。真正需要警惕的是在布局回调(onSizeChanged、onPlaced、自定义 LayoutModifier)和绘制回调(drawBehind、Canvas)中写入状态,而这些状态又同时被更早的阶段读取。延迟读取和向后写入是方向相反的两件事:延迟读取把"读"往后推,是优化;向后写入把"写"往后推,但更早阶段还在读它,是逆流。


五、derivedStateOf 与 lambda modifier 的分工:去重 vs 换层

第6课讲 derivedStateOf 是"读时重算、结果去重"的过滤器。这一课的 lambda modifier 是"把读取推迟到布局或绘制"的阶段工具。两者经常被混用,但边界很清楚:

derivedStateOf 解决"读得太频繁":输入变化很多次,但派生结果很少变。它让下游只在结果真正变化时才失效。它不改变读取发生在哪个阶段。

lambda modifier 解决"读得太早":值本身每帧都在变,但没必要在组合阶段读它。它让读取发生在布局或绘制,从而跳过组合。它不保证结果去重。

官方在讨论状态与稳定性优化时,把这两条路径并列得很清楚:偏移用 Modifier.offset { } 从组合阶段跳到布局阶段;alpha/旋转用 Modifier.graphicsLayer { } 从组合阶段跳到绘制阶段;而 derivedStateOf 处理的是"输入频率高于输出频率"的派生状态压缩。

一个具体的组合场景:滚动位置既用来驱动一个偏移量,又用来派生"是否显示回到顶部按钮"。偏移量用 Modifier.offset { } 读取滚动状态,把每帧的偏移更新挡在组合之外;按钮可见性用 derivedStateOf { firstVisibleItemIndex > 0 },把几十次索引变化压缩成一次布尔翻转。两者不是替代关系,而是分别处理"读得太早"和"读得太频繁"。

边界也在于此:不要把 derivedStateOf 当成延迟读取的替代品。 如果一个值每帧都在变,而且每次变化都应该反映到 UI 上(比如偏移、透明度),derivedStateOf 的结果也会每帧变化,去重不发生,它只是多了一层订阅。此时正确的工具是 lambda modifier。反过来,如果一个值只在布局阶段使用,但它的消费需求是"跨阈值才变化",单纯用延迟读取不够——因为延迟读取仍然会让布局每次重新执行,而 derivedStateOf 才是把高频输入压缩成低频结果的那个工具。两者的边界不是"二选一",而是"先问频率比,再问读取阶段"。

两者的分工可以用一张决策图收束:

flowchart TD
  Q["一个高频变化的状态"] --> Q1{"UI 消费的是每帧值,还是低频派生结果?"}
  Q1 -->|"每帧值(偏移、alpha)"| D1["lambda modifier:把读取推迟到布局或绘制"]
  Q1 -->|"低频派生结果(是否显示按钮)"| D2["derivedStateOf:压缩频率、结果去重"]
  D1 --> D3["两者可叠加:先压缩频率,再延迟读取"]
  D2 --> D3

六、决策框架:一个状态读取应该放在哪一层

第一问:这个值的变化频率有多高? 高频(滚动、动画、拖拽)优先考虑延迟读取;低频(用户选择、一次性结果)直接读取通常就够了。

第二问:这个值在后续阶段被消费时,是否真的不需要参与组合? 如果它只影响布局(偏移、尺寸约束),用 Modifier.offset { }、Modifier.layout { } 或自定义 LayoutModifier;如果它只影响绘制(alpha、颜色、旋转、缩放),用 Modifier.graphicsLayer { } 或 Modifier.drawBehind { }。

第三问:如果使用 lambda modifier,值确实在 lambda 内被读取吗? 把 lambda 传下去,但下游在组合阶段就读取了它,延迟就没有发生。确认读取点落在布局或绘制回调内部,而不是在 Composable 正文里。

第四问:这个状态是否在其他地方被组合阶段读取? 如果有,延迟读取只保护了 modifier 内部的那次读取,其他读取点仍然会触发重组。要真正跳过组合,必须保证这个状态在组合阶段没有读取点。

第五问:有没有在较晚的阶段写入更早阶段依赖的状态? 如果在布局回调(onSizeChanged、onPlaced、LayoutModifier)或绘制回调中写入组合阶段读取的状态,那是向后写入,需要把状态的所有权或读取点重新安排。

第六问:如果值高频变化但 UI 只需要低频结果,应该用 derivedStateOf 还是延迟读取? 如果 UI 消费的是"派生后的低频结果",用 derivedStateOf;如果 UI 消费的仍然是每帧变化的值,只是不想在组合阶段读它,用 lambda modifier。两者处理的是不同形状的问题,可以叠加使用:先用 derivedStateOf 压缩频率,再用 lambda modifier 把读取推到合适的阶段。

六问决策框架的整体流程:

flowchart TD
  S["待优化的状态读取"] --> Q1{"变化频率高吗?"}
  Q1 -->|"低频"| E1["直接读取通常足够"]
  Q1 -->|"高频"| Q2{"只影响布局或绘制吗?"}
  Q2 -->|"只影响布局"| E2["Modifier.offset / layout"]
  Q2 -->|"只影响绘制"| E3["graphicsLayer / drawBehind"]
  Q2 -->|"仍需参与组合"| Q3{"组合阶段还有其他读取点吗?"}
  Q3 -->|"有"| E4["先消除组合阶段读取点"]
  Q3 -->|"没有"| Q4{"存在向后写入吗?"}
  Q4 -->|"有"| E5["调整状态所有权或读取阶段"]
  Q4 -->|"没有"| E6["按频率比选择 derivedStateOf 或延迟读取"]

七、习题:15 道阶段与读取边界检验

第 1 题(选择)

Compose 一帧的三个阶段,正确顺序是: A. 组合 → 绘制 → 布局 B. 布局 → 组合 → 绘制 C. 组合 → 布局 → 绘制 D. 绘制 → 布局 → 组合

参考答案:C。

解读: 官方定义严格按顺序执行:组合构建 UI 树,布局测量和放置,绘制发出画布命令。状态读取的优化方向是"尽量向后推迟",因为越靠后的阶段重新执行时,需要重跑的工作越少。顺序反过来理解,就会把"延迟读取"误解为"提前读取"。

第 2 题(判断)

一个状态在绘制阶段被读取,它的变化会触发重组。

参考答案:错。

解读: 状态读取记录的是"状态与读取它的阶段之间的依赖"。绘制阶段读取的状态,变化时只会使绘制失效,组合和布局都可以跳过。这正是 Modifier.graphicsLayer { alpha = animatedAlpha } 比 Modifier.alpha(animatedAlpha) 更高效的原因:后者在组合阶段读取,每一帧动画都触发重组;前者把读取推迟到绘制,每一帧只触发重绘或层属性更新。

第 3 题(代码分析)

下面代码在滚动时,每次 scrollState.value 变化会发生什么?如何优化?

val offset = scrollState.value
Box(modifier = Modifier.offset(x = offset.dp, y = 0.dp))

参考答案: scrollState.value 在组合阶段被读取,每次滚动偏移变化都会使读取它的组合作用域重组,重新执行 Composable 并产出新的 Modifier。优化方式是使用 lambda 版本的 offset:

Box(modifier = Modifier.offset { IntOffset(scrollState.value, 0) })

读取被推迟到布局的放置子步骤,滚动时跳过组合,只重新放置和绘制。

解读: 这是延迟读取最标准的入门案例。非 lambda 的 Modifier.offset(x = ...) 在组合阶段求值参数,状态一变,组合就失效;lambda 的 Modifier.offset { ... } 把求值放进布局阶段的放置逻辑,组合阶段只传递一个稳定的 lambda。边界在于:如果 scrollState.value 同时还在组合阶段被别的地方读取(比如用来决定文本内容),那部分仍然会触发重组,延迟读取只保护了 modifier 内部的这次读取。

第 4 题(选择)

关于 Modifier.alpha(alpha) 和 Modifier.alpha { alpha },下列说法正确的是: A. 两者行为完全等价,后者只是语法糖 B. 前者在组合阶段读取,后者在绘制阶段读取 C. 前者在布局阶段读取,后者在绘制阶段读取 D. 后者会让状态变化不再引起任何失效

参考答案:B。

解读: Modifier.alpha(alpha) 在组合阶段读取 alpha 的值,作为参数传入;Modifier.alpha { alpha } 把读取推迟到绘制阶段(或通过 graphicsLayer 的对应机制)。官方把 graphicsLayer { } 的 lambda 形式列为 alpha/旋转动画的优化路径:跳过组合和布局,直接进入绘制。D 错在"不再引起任何失效":绘制阶段仍然会失效,只是失效的范围缩小到了绘制。A 错在"等价":读取阶段不同,代价完全不同。

第 5 题(判断)

把状态读取放进 Modifier.offset { } 的 lambda 里,状态变化就完全不会引起任何重组。

参考答案:错(有条件成立)。 这句话只在"该状态没有被组合阶段的其他代码读取"时成立。如果同一个状态还在 Composable 的正文中被读取,那部分读取仍然会在状态变化时触发重组,Modifier.offset { } 只能保护它内部的那次读取。延迟读取的边界是读取点,不是状态本身:同一个状态可以同时在多个阶段被读取,每个读取点的阶段决定了各自失效的范围。

解读: 这是延迟读取最常见的误判之一:把"把读取移进 lambda"当成"把状态从组合中隔离出去"。实际上,状态只是一个对象;决定代价的是"哪些代码在哪个阶段读了它"。要真正跳过组合,必须确保这个状态在组合阶段没有被任何代码读取,而不仅仅是在 modifier 内部被延迟了。

第 6 题(简答)

什么是"向后写入"?为什么它在 Compose 的阶段模型中是一个需要警惕的模式?

参考答案: 向后写入是指状态在比读取它更晚的阶段(或同一组合传递中更靠后的下游作用域)被修改,从而迫使 Compose 安排更早的阶段重新运行。严格来说,它要求"先读后写":组合阶段读取了某个状态,布局或绘制阶段又向它写入新值,组合就会被失效。后果包括额外的帧渲染和丢帧、首帧使用无效默认值导致的视觉闪烁,以及布局尺寸与状态互相写回时可能出现的无限重组循环。

解读: 官方把阶段描述为"严格有序、向前流动"的:组合 → 布局 → 绘制。状态变化也应该沿这个方向流动:组合更新状态,布局或绘制读取它,是合法的;布局或绘制写入状态,组合读取它,就是逆流。向后写入不一定崩溃,但它是未优化的重组循环。一个典型的合法例外是事件回调(onClick、onValueChange)在帧外修改状态;布局回调(onSizeChanged、onPlaced)不算事件,如果它们在组合读取之后写入,就会构成向后写入。

第 7 题(代码分析)

下面代码有什么性能问题?请给出优化后的写法。

val alpha by animateFloatAsState(targetValue)
Box(modifier = Modifier.alpha(alpha))

参考答案: animateFloatAsState 返回的 alpha 在组合阶段被读取,动画每一帧都会使读取它的 Composable 重组,产生每秒 60 到 120 次重组。优化方式是把读取推迟到绘制阶段:

val alpha by animateFloatAsState(targetValue)
Box(modifier = Modifier.graphicsLayer { this.alpha = alpha })

graphicsLayer { } 的 lambda 在绘制阶段读取 alpha,动画帧只触发重绘或层属性更新,跳过组合和布局。

解读: 这是"高频动画属性"的标准边界案例。Modifier.alpha(alpha) 的问题不在于 animateFloatAsState 本身,而在于读取发生在组合阶段:动画的每一帧都是一次状态变化,组合阶段读取意味着每一帧都重新组合。graphicsLayer { } 把读取移到绘制阶段,动画仍然每帧变化,但失效范围从"组合 + 布局 + 绘制"缩小到"绘制"。官方把这个模式列为 alpha 和旋转动画的推荐写法。一个更细的边界:Modifier.graphicsLayer { } 会把内容提升为独立渲染层,层属性更新甚至可以绕过内容重绘,只做合成。

第 8 题(选择)

下列哪一组"常见修饰符 → 延迟替代项"是正确的? A. .background(color) → .drawBehind { drawRect(color) } B. .offset(0.dp, y) → .offset { IntOffset(0, y.roundToPx()) } C. .alpha(a) → .graphicsLayer { alpha = a } D. 以上全部正确

参考答案:D。

解读: 官方修饰符阶段细分的快速参考表列出了这三组替换:background 用 drawBehind 把颜色读取/绘制推迟到绘制阶段;offset 用 lambda 版本把偏移读取推迟到布局放置;alpha(以及 rotate、scale)用 graphicsLayer { } 把读取推迟到绘制阶段。这三组替换的共同点不是"语法不同",而是"读取发生的阶段从组合后移到了布局或绘制",从而跳过组合阶段。

第 9 题(判断)

延迟读取总是比直接读取更好,任何状态都应该尽量放进 lambda modifier 里。

参考答案:错。 延迟读取有收益的前提是:值在后续阶段被消费,且变化频率足够高。如果状态变化频率很低,延迟读取带来的收益可以忽略,lambda 本身还有对象分配成本。如果值最终仍然在组合阶段被读取,把 lambda 传下去并不会延迟读取,只是多了一层间接。官方明确:lambda provider 只在值于布局或绘制阶段被读取时才有收益;如果在组合阶段读取,直接传原始值更合适。延迟读取是工具,不是教条。

解读: 这道题考的是避免把"延迟读取"变成新的万能口诀。延迟读取解决的是"读得太早"的问题;如果读取本来就不早,或者值根本不常变,延迟就没有目标可优化。判断依据是"读取点在哪一阶段"和"变化频率有多高",不是"有没有用 lambda"。

第 10 题(代码分析)

下面代码想根据动画尺寸调整一个圆形的大小。它每次动画帧都会重组,为什么?如何用自定义 LayoutModifier 或 lambda 参数避免?

@Composable
fun MyShape(size: Dp) {
    Box(
        modifier = Modifier
            .background(Purple80, CircleShape)
            .size(size)
    )
}

参考答案: size 作为普通参数传入,MyShape 在组合阶段读取它,动画每一帧 size 变化都会使 MyShape 重组。优化方式是把 size 改成 lambda 参数 size: () -> Dp,并在 Modifier.layout { } 的测量逻辑中调用 size():

@Composable
fun MyShape(size: () -> Dp) {
    Box(
        modifier = Modifier
            .background(Purple80, CircleShape)
            .layout { measurable, _ ->
                val sizePx = size().roundToPx().coerceAtLeast(0)
                val placeable = measurable.measure(
                    Constraints.fixed(sizePx, sizePx)
                )
                layout(sizePx, sizePx) { placeable.place(0, 0) }
            }
    )
}

这样 size 的读取发生在布局测量阶段,动画帧只使布局失效,跳过组合。

解读: 这是官方 codelab 中"用自定义布局推迟 Compose 阶段"的案例。关键不是"用了 layout 修饰符",而是"读取发生在 layout 的测量 lambda 内部"。如果把 size() 的调用写在 MyShape 的 Composable 正文里,即使参数是 lambda,读取仍然在组合阶段,优化不会发生。边界在于读取点,不在于 API 的形状。另一个细节:Modifier.size(size) 本身也接受 Dp,它的问题和非 lambda 的 offset 相同——值在组合阶段被读取;把 size 换成 lambda 只是第一步,真正的收益来自在 layout 的测量逻辑里调用它。

第 11 题(简答)

derivedStateOf 和 lambda modifier 都能"减少重组",它们的边界分别在哪里?

参考答案: derivedStateOf 解决"读得太频繁":输入变化很多次,但派生结果很少变,它让下游只在结果变化时失效,是读侧的结果去重。lambda modifier 解决"读得太早":值本身高频变化,但不需要在组合阶段读,它把读取推迟到布局或绘制,是阶段上的读取延迟。前者不改变读取发生在哪个阶段,后者不保证结果去重。一个高频变化且每帧都需要反映到 UI 的值(如偏移、alpha)应该用 lambda modifier;一个高频变化但 UI 只关心低频派生结果的值(如"是否显示回到顶部按钮")应该用 derivedStateOf。两者可以叠加:先用 derivedStateOf 压缩频率,再用 lambda modifier 把读取推到合适的阶段。

解读: 这道题把第6课和第7课的核心边界放在一起。两者不是替代关系,而是处理不同形状的问题。如果误用:对每帧变化的偏移用 derivedStateOf,结果每帧都变,去重不发生,只是多一层订阅;对低频派生结果用延迟读取,读取被推到绘制阶段,但结果本身变化不频繁,延迟没有拦截到任何重组。正确的判断顺序是:先问"变化频率 vs 消费频率"(决定 derivedStateOf 是否有用),再问"消费发生在哪一阶段"(决定 lambda modifier 是否有用)。

第 12 题(场景设计)

一个列表在滚动时同时做两件事:(1)根据滚动偏移让头部图片产生视差位移;(2)当列表滚过第一项时显示"回到顶部"按钮。请分别设计实现,并说明为什么不把两件事都塞进 derivedStateOf。

参考答案: 视差位移用 lambda modifier:Modifier.offset { IntOffset(0, (scrollState.value * 0.5f).roundToInt()) },在布局阶段读取滚动状态,滚动时跳过组合。按钮可见性用 derivedStateOf:val showButton by remember { derivedStateOf { listState.firstVisibleItemIndex > 0 } },把高频索引变化压缩成低频布尔翻转。不把视差塞进 derivedStateOf 的原因:视差结果每帧都在变,derivedStateOf 的结果去重不会发生,它只是把读取从组合阶段搬到派生状态里,并没有解决"组合阶段读取"的问题;真正需要的是延迟到布局阶段。不把按钮可见性只靠 lambda modifier 的原因:它的消费点是组合阶段的条件渲染(是否发出按钮节点),而不是布局或绘制属性,延迟读取无法替代"根据布尔值决定组合内容"的需求。

解读: 这道题考的是把两种工具放在同一个高频场景里,判断各自的适用边界。视差是"每帧都变、每帧都要用、但只在布局阶段用",属于 lambda modifier 的形状。按钮可见性是"每帧都变、但只在跨过阈值时用",属于 derivedStateOf 的形状。两件事的输入相同(滚动状态),但消费语义不同,所以工具不同。

第 13 题(判断)

在布局阶段读取状态,状态变化时一定不会触发重组。

参考答案:错(过于绝对)。 布局阶段读取状态,状态变化时通常只使布局失效,组合可以被跳过。但如果存在向后写入——例如布局回调又向组合阶段依赖的状态写入了新值——组合仍然会被失效。更准确的说法是:布局阶段的读取本身记录的是"状态与布局阶段的依赖",这次读取的变化只直接使布局失效;但整个帧中是否发生重组,还取决于有没有其他代码在组合阶段读取同一个状态,以及有没有向后写入。阶段边界不是孤立的,它和读取点的分布、写入的方向共同决定实际行为。

解读: 这道题防止把"布局阶段读取"简单化成"零重组"。阶段模型是"读取记录依赖",不是"读取隔离一切"。一个状态可以同时在多个阶段被读取,每个读取点各自记录依赖;只有所有组合阶段的读取点都不存在时,状态变化才能完全跳过组合。判断实际行为时,要看整个读取网络,而不是单个读取点。

第 14 题(简答)

为什么在 Modifier.drawBehind { } 或 Canvas 的绘制代码中写入一个组合阶段读取的状态,可能导致无限循环?

参考答案: 绘制阶段写入状态,而这个状态在组合阶段被读取,会构成向后写入:绘制使组合失效,组合重新执行后又再次进入绘制,绘制再次写入,形成"绘制 → 组合 → 布局 → 绘制"的循环。如果写入的值不稳定,或者每次绘制都产生新的、不相等的值,循环就不会收敛。官方把"在组合中读取,在绘制中写入"明确列为向后写入,并指出它可能造成无限重组循环。需要补充一个条件:如果写入的值最终收敛到一个稳定值,循环会在若干帧后停止;只有值持续变化、无法收敛时,才会形成真正的无限循环。

解读: 这道题对应官方向后写入文档中的对称失败模式:在组合阶段读取,在绘制阶段写入,是逆流。绘制是最后一个阶段,它在帧的末尾执行;如果它在末尾修改了更早阶段依赖的状态,Compose 只能安排下一帧重新从头执行,而下一帧的绘制又做同样的事情,循环就形成了。正确的做法是把状态的写入放在事件回调或协程中(帧外),而不是放在绘制或布局回调中;如果必须在布局/绘制中写,要确保没有组合阶段的读取者依赖它,或者把读取也迁移到同一阶段。

第 15 题(综合简答)

有人说:"Compose 的性能优化就是两件事:少重组,少重绘。"评价这个说法,并结合第6课和第7课的内容,说明一个更准确的优化框架应该包含哪些问题。

参考答案: 这个说法方向对,但过于粗糙。它把"重组"和"重绘"当成两个独立的开关,而 Compose 的实际代价由"状态读取发生在哪一阶段"和"读取的结果是否真的需要向下传播"共同决定。一个更准确的框架至少包含四个问题:(1)这个状态的变化频率是多少?(2)它被消费的频率是多少?(决定 derivedStateOf 是否有意义)(3)它在哪一阶段被读取?能不能推迟到布局或绘制?(决定 lambda modifier 是否有意义)(4)有没有较晚阶段写入较早阶段读取的状态?(向后写入)。只有把"阶段"和"去重"分开看,才能判断某一项优化是在减少无效工作,还是只是把开销换了一个位置。

解读: 这道题把第6课的"频率比"和第7课的"阶段"收拢成一个统一的判断框架。"少重组"是结果,不是方法:真正的方法是"把读取放到正确的阶段"和"只让有意义的变化向下传播"。derivedStateOf 处理后者,lambda modifier 处理前者;向后写入是两者都要警惕的反模式。缺少任何一个维度,优化都可能变成"看起来改了写法,实际开销没变甚至更差"。


八、本节课知识点总结

阶段模型。 Compose 一帧严格按组合 → 布局 → 绘制执行。在任意阶段读取状态,Compose 记录该状态与该阶段的依赖;状态变化时,只重新执行读取它的阶段及其后续阶段。阶段跳过机制只对"读取点位于较晚阶段"的状态生效。

延迟读取。 把状态读取从组合阶段推迟到布局或绘制阶段,可以跳过组合,减少甚至消除重组。实现方式是传递 lambda 而不是状态值:布局属性用 Modifier.offset { }、Modifier.layout { };绘制属性用 Modifier.graphicsLayer { }、Modifier.drawBehind { }。graphicsLayer 进一步把内容提升为独立渲染层,属性更新可以绕过内容重绘。延迟读取的收益取决于"读取点确实落在后续阶段",而不是 lambda 的语法。布局内部还要区分测量子步骤和放置子步骤:Modifier.layout { } 在测量中读取,Modifier.offset { } 在放置中读取。

无效化范围。 状态读取发生在哪一阶段,失效就限于该阶段及之后;但组合阶段的读取会使最近的非 inline 重组作用域整体失效,所以"在 modifier 里读"是把失效从"大作用域 + 全阶段"压缩到"小节点 + 单阶段",不是消除失效。同一个状态在多个阶段被读取时,每个读取点各自记录依赖;只要组合阶段还有读取点,重组就仍然会发生。

向后写入。 在较晚阶段写入较早阶段读取的状态,会迫使 Compose 重新执行更早的阶段;后果包括额外帧、首帧闪烁和潜在的无限重组循环(值不收敛时)。状态变化应沿阶段向前流动;事件回调和协程是合法的写入上下文,布局和绘制回调中的写入需要特别警惕。延迟读取是"读往后推",向后写入是"写往后推但读不往后推",两者方向相反。

与 derivedStateOf 的分工。 derivedStateOf 处理"读得太频繁",做结果去重;lambda modifier 处理"读得太早",做阶段延迟。一个高频变化且每帧都需要消费的值用 lambda modifier;一个高频变化但 UI 只关心低频派生结果的值用 derivedStateOf。两者可以叠加:先压缩频率,再延迟读取。

决策框架。 六问:变化频率、消费频率、读取阶段、其他组合阶段读取点、是否有向后写入、用去重还是延迟。

一句话收束: 第3课回答"值存在哪儿",第4课回答"动作拴在哪儿",第5课回答"哪儿由什么定义",第6课回答"值如何派生、派生结果如何过滤"。这一课回答的是:同一个值,在哪一层被读取,决定了它的变化要付出多少代价;而写入的方向,决定了这些代价会不会逆流成循环。 Modifier 的 lambda 不是语法糖,它是把读取安放到正确阶段的工具;而"正确阶段"的边界,由阶段模型和向后写入的反向约束共同划定。读得晚,比读得少更根本;写错方向,比读错地方更危险。


九、下期预告

第8课:rememberSaveable 与状态恢复的边界——Saver、Bundle 与"什么值得跨进程存活"

第3课讲 remember 时,我们说的是"值跨重组存活"。但跨重组不等于跨配置变更,更不等于跨进程重建。rememberSaveable 被当成"更持久的 remember"来用,但它的边界比这窄得多:它只保存能进入 Bundle 的值,它的 Saver 有严格的类型和大小约束,它的恢复时机与 SavedStateRegistry 和组合身份都有关系。

下一课拆三件事:rememberSaveable 到底把值存在哪里、什么时候恢复;Saver 的边界在哪里,为什么复杂对象不能直接"扔进去";以及"状态恢复"和"状态持久化"是两件不同的事——前者属于 UI 框架,后者属于数据层,混用会导致 TransactionTooLargeException 或静默丢失。第7课讲的是"读取发生在哪一层",第8课讲的是一个值能活多久、活在哪个存储介质里,以及这个介质的边界如何反过来限制你允许什么状态进入恢复流程。