【探秘 Jetpack Compose 框架深水区】第10课:LazyList 的测量边界——为什么你的列表会在测量/布局阶段闪烁

0 阅读15分钟

摘要:普通 Column 在组合完成后进入测量;LazyColumn 借助 SubcomposeLayout,在测量过程中 subcompose 可见项,形成“边测量边组合”。这个反转带来三条硬边界:SubcomposeLayout 不支持 intrinsic 测量,LazyColumn、BoxWithConstraints、TabRow 共享这条禁令;LazyListState 的字段可靠性分级不同,firstVisibleItemIndex 官方建议包装,layoutInfo 被明确要求“避免在组合中使用”;在布局阶段写、组合阶段读状态(如 onSizeChanged)属于官方判定的“向后写入”,会导致首帧闪烁、额外帧乃至重组循环。文章给出 trace 诊断入口、四问决策框架与 8 道测量边界检验。

约定:本文标题中的“测量阶段”泛指测量/布局阶段;严格来说,onSizeChanged 回调发生在布局阶段。

目录

前言

第9课问的是:项被回收后,状态归谁管。这一课往下挖一层,挖到一个更底层、也更反直觉的地方:列表的测量,不是“一口气量完”的。

先从一个现象说起。你写了一个 LazyColumn,项里用 onSizeChanged 读自己的高度,再把高度显示在文字里。滚动时文字在闪,高度数字一会儿这个值、一会儿那个值。你没改任何状态,它自己就在跳。另一个更常见的现象是:列表首帧位置总差一点,要等第二帧才对齐。

这两个现象看着不一样,根子却是同一个:LazyColumn 的可见项组合发生在测量过程中,而且测量可能发生多次。 你在测量/布局阶段读到、写到的东西,时序都和普通 Column 不一样。

用一个类比来理解。普通 Column 像先量好所有布料的尺寸,再统一裁剪:测量开始的时候,要裁什么已经确定了。LazyColumn 像边量边裁:它得先知道布料(可用空间)有多宽,才能决定裁哪一段,而“裁哪一段”本身就是组合。这个顺序反转,不是实现细节,而是一条边界。

这一课分三步:先看 LazyColumn 为什么必须“边测量边组合”,以及这个反转的硬性代价;再看 LazyListState 的字段为什么不能一视同仁;最后看测量/布局阶段写状态如何制造闪烁和循环,以及怎么在 trace 里确认它。

一、普通 Column 和 LazyColumn,测量顺序根本不一样

普通 Column 的流程很老实:先组合,再测量。 你把十个子项交给它,它先把十个子项全部组合出来,形成完整的组合树;然后进入测量阶段,挨个问子项“你想要多大”,最后决定自己的尺寸和子项位置。

这个顺序有个重要前提:测量开始时,要测什么已经确定了。 组合树已经在那儿,测量只是对既有的树求尺寸。

LazyColumn 做不到。它面临一个死结:不能提前组合所有项,否则一万项就得组合一万个,内存直接爆;也不能在组合阶段就知道“哪几项可见”,因为“可见”取决于父级给了多少空间,而空间是测量阶段才拿到的。

于是它只能反过来:先测量,看看父级给了多少空间,算出大概能放几项,然后在测量过程中把需要显示的项临时组合出来,再测量它们的尺寸。

这个“在测量过程中组合”的能力,来自 SubcomposeLayout。它的 measure policy 里多了一个方法 subcompose,语义是:在测量时把这段内容组合出来,给我一组可以测量的对象。LazyColumn 在测量循环里的核心动作,简化到本质,类似:

// 简化伪代码:跑到这一行,才把这一项组合出来
val measurable = subcompose(index) { ItemContent(items[index]) }

普通 Column 在进入测量循环之前,所有子项都已经组合好;LazyColumn 是跑到这一行才组合。这一行之后,才轮到 measure 和 layout。所以它的实际顺序是:先测量可用空间 → 决定组合哪几项 → 组合这几项 → 测量它们 → 决定滚动位置和可见范围。

flowchart LR
  subgraph C1["普通 Column"]
    A1["组合全部子项"] --> A2["测量已存在的组合树"]
    A2 --> A3["布局与放置"]
  end
  subgraph C2["LazyColumn / SubcomposeLayout"]
    B1["测量可用空间"] --> B2["决定组合哪几项"]
    B2 --> B3["subcompose 组合这几项"]
    B3 --> B4["测量这些项"]
    B4 --> B5["决定滚动位置与可见范围"]
    B5 -.->|"滚动中可能重复"| B1
  end

这个顺序反转不是实现细节,而是一条边界:测量不再只是“对已经确定的组合树求尺寸”,而是“一边决定组合什么,一边测量”。

接回第9课:在测量阶段被组合出来的项,生命周期规则和正常组合的项一样——remember 一样会在离开组合时丢失,rememberSaveable 一样走寄存柜,LaunchedEffect 一样跟着组合走。区别只在时序:它的组合发生在测量内部,所以可能在一帧里被组合、测量、丢弃、再组合,也可能在滚动中被反复触碰。第9课讲“状态归谁管”,这一课讲“它在时间轴上的哪一段被创建和销毁”。

二、这个反转带来一个硬后果:intrinsic 测量没了

SubcomposeLayout 的“测量中组合”有一个绕不过去的代价:不支持 intrinsic 测量。

intrinsic 测量,简单说就是“在拿到具体约束之前,先问组件:你大概想要多大?”有些父级布局需要这个信息做决策,比如按比例分配空间。问题在于,SubcomposeLayout 的内容组合本身依赖约束——你得先告诉我空间多大,我才知道组合哪几项;而 intrinsic 测量要求“先问尺寸、再给约束”,两者时序正好相反。这是一个先有鸡还是先有蛋的冲突:intrinsic 说“先告诉我尺寸”,SubcomposeLayout 说“先给我约束,我才能告诉你尺寸”。

所以官方直接把这条路堵死了。SubcomposeLayout.kt 的异常信息写得很清楚:

Asking for intrinsic measurements of SubcomposeLayout layouts is not supported. This includes components that are built on top of SubcomposeLayout, such as lazy lists, BoxWithConstraints, TabRow, etc.

翻译过来就是:LazyColumn 这类建立在 SubcomposeLayout 之上的组件,不支持 intrinsic 测量。这不是 LazyColumn 独有的问题,BoxWithConstraints、TabRow 等所有基于 SubcomposeLayout 的组件共享同一条禁令。 性能 codelab 也提醒,BoxWithConstraints 会在测量阶段将组合拆分成多个工作块;如果不需要基于可用空间切换 UI,应避免在列表项里使用它。

一个更准的现场:

// 崩溃:父级 Row 为了确定自身高度,向 LazyColumn 发起 intrinsic 查询
Row(modifier = Modifier.height(IntrinsicSize.Min)) {
    LazyColumn {
        items(10) { index ->
            Text("item $index")
        }
    }
}

这里要把归因说准:崩溃的直接原因不是某一行代码“自己触发了 intrinsic”,而是有父级布局或某个 modifier 组合为了确定尺寸,向 LazyColumn 发起了 intrinsic 查询。 LazyColumn 作为 SubcomposeLayout 之上的组件,以 IllegalStateException 拒绝了这个问题。排查自己的崩溃时,要找的是“谁在向 LazyColumn 问 intrinsic”,而不是盯着某个 modifier 本身。如果你在项里看到 fillParentMaxHeight,也不要直接把它当根因。

flowchart TD
  P["父级布局需要确定尺寸"] --> Q["向子级发起 intrinsic 查询"]
  Q --> R{"子级是否基于 SubcomposeLayout"}
  R -->|"是:LazyColumn / BoxWithConstraints / TabRow"| S["抛出 IllegalStateException"]
  R -->|"否:普通 Layout"| T["返回 intrinsic 尺寸,正常测量"]
  S --> U["排查方向:找出谁在向 LazyColumn 问 intrinsic"]

官方在异常信息里也给了缓解方向:如果 intrinsic 测量是为了实现“match parent”尺寸,可以考虑把父级换成自定义布局,控制子项测量顺序,让 intrinsic 测量不再必要;或者给组件加上尺寸 modifier,让 intrinsic 查询能快速返回确定值。一旦用了“测量中组合”,就放弃了 intrinsic 这一整类测量能力,这不是靠写法能绕过的。

三、LazyListState 的字段,可靠性不一样

理解了“测量中组合”,再看 LazyListState 的字段,就不能把它们当成一组同质的、随时可读的普通状态。官方 API 参考对两个字段的措辞力度差别很大。

firstVisibleItemIndex 的原文是:“observable and if you use it in the composable function it will be recomposed on every change causing potential performance issues.” 如果要副作用,用 snapshotFlow;如果确实要在组合中用,“consider wrapping the calculation into a derived state in order to only have recompositions when the derived value changes.” 翻译一下:它仍是 observable 的,直接读同样会随每次变化触发重组,但官方定性是“有性能代价,建议包装”。

layoutInfo 的原文严厉得多:“observable and is updated after every scroll or remeasure. If you use it in the composable function it will be recomposed on every change causing potential performance issues including infinite recomposition loop. Therefore, avoid using it in the composition.” 两段并置,分级一目了然:前者是“建议包装”,后者是**“避免在组合中使用”**,并且明确点名“无限重组循环”。

“慢一拍”是什么感觉?假设你在 LazyColumn 上面放了一个“当前第几项”的标题:

val listState = rememberLazyListState()
LazyColumn(state = listState) { /* ... */ }

// 组合阶段读 firstVisibleItemIndex
Text("现在是第 ${listState.firstVisibleItemIndex + 1} 项")

快速滑动时,这个数字可能滞后于滚动动画中的实际位置;滑动停下后,它会对齐。这不是 bug,而是“测量完成后的锚”和“滚动动画进行中的实际位置”之间天然存在时差。如果需要它跟上滑动,通常用 snapshotFlow 收集,再用平滑过渡呈现。

看一个 layoutInfo 的反例:

// 危险:在组合正文里直接读 layoutInfo
val lastVisible = listState.layoutInfo.visibleItemsInfo.lastOrNull()
Text("last visible: ${lastVisible?.index}")

滚动中的每一次测量更新,都会让 Text 所在的组合位置失效。如果这个读取恰好又影响了布局或滚动行为,就可能形成“测量 → 组合读取 → 触发新的测量”的反馈环。官方说的“无限重组循环”,指的就是这种形状。

layoutInfo 不是不可用,而是它的读取时机需要被控制。如果只是想知道“是不是滚到底了”,用 derivedStateOf 把高频变化的 layoutInfo 压成低频布尔值:

val isAtBottom by remember(listState) {
    derivedStateOf {
        val layoutInfo = listState.layoutInfo
        val lastVisible = layoutInfo.visibleItemsInfo.lastOrNull()
        lastVisible?.index == layoutInfo.totalItemsCount - 1
    }
}
// 只在 isAtBottom 翻转时重组,而不是每次滚动都重组
Text("at bottom: $isAtBottom")

如果要在变化时做副作用,用 snapshotFlow 送进 LaunchedEffect。

一句话记住:firstVisibleItemIndex 是“测量完成后的锚”,官方建议包装后使用;layoutInfo 是“测量本身的产物”,官方要求“避免在组合中使用”,并明确点名无限重组循环。

四、在测量/布局阶段写状态,为什么会闪

第7课讲过“向后写入”:在较晚的阶段写一个较早阶段读的状态,会逼着 Compose 把更早的阶段重新跑一遍。官方“向后写入”页面的对照表里有一格写得很明确:读取阶段“组合”,写入上下文“布局(onSizeChanged、LayoutModifier)”,是否可接受?——“否 - 反向写入”,原因——“布局使 Composition 失效 → Recomposition 循环”。

在 Lazy 项里,onSizeChanged 就是最常见的“布局阶段写入”。

@Composable
fun ItemWithMeasuredHeight(index: Int) {
    var height by remember { mutableStateOf(0) }   // 组合阶段读取

    Text(
        text = "item $index, height = $height",
        modifier = Modifier.onSizeChanged { height = it.height }   // 布局阶段写入
    )
}

height 在组合阶段被用来构造 text,onSizeChanged 在布局阶段把它改掉。于是测量一完成,组合就失效;组合重跑,测量可能再次触发 onSizeChanged。

把时序拆开看,第一帧是这样的:组合阶段读到 height = 0,文本显示“height = 0”;布局阶段测量完成,onSizeChanged 把真实高度写回 height;因为 height 在组合阶段被读过,组合被标记为失效;第二帧重组,文本显示真实高度。第一帧的“height = 0”已经画到屏幕上了,用户看到的就是一次闪烁。

官方把这条路径的后果分成三类,每一类在 Lazy 列表里都会被放大。

第一类,首帧正确性问题。 组件在首帧会用零尺寸或默认值渲染,第二帧才拿到真实尺寸。视觉上就是列表“闪一下”或“跳一下”。

第二类,额外的帧渲染和丢帧。 测量一完成,组合就失效;组合重跑,测量可能再次触发写入。如果写入的值不能迅速稳定,就会出现连续帧的多余组合传递。

第三类,无限重组循环。 如果尺寸变化又反过来改变布局尺寸,而布局尺寸继续把新值写回状态,屏幕可能每一帧都在重组,永远停不下来。

这三类后果共享同一个反馈环:

flowchart LR
  A["组合阶段读取 height"] --> B["布局阶段 onSizeChanged 写入 height"]
  B --> C["组合失效,触发重组"]
  C --> D{"写入值是否迅速稳定"}
  D -->|"否"| A
  D -->|"是"| E["首帧闪烁 / 额外帧"]
  D -->|"尺寸又改变布局尺寸"| F["无限重组循环"]

修复方向不是“把 onSizeChanged 藏起来”,而是让测量/布局阶段写入的状态,不要在组合阶段被读。如果这个尺寸只用于绘制或布局决策,就把它留在测量/布局阶段消费;如果它必须影响组合内容,用 Layout 在测量阶段就把内容决定好,而不是先组合、再回写。

// 修复前:尺寸写回状态,在组合阶段被读,构成向后写入
var h by remember { mutableStateOf(0) }
Text("h=$h", modifier = Modifier.onSizeChanged { h = it.height })

// 修复后:尺寸在测量阶段被读取和使用,不写回任何组合状态
Layout(content = { Text("item") }) { measurables, constraints ->
    val placeable = measurables.first().measure(constraints)
    // 在这里直接使用 placeable.height 做布局决策
    layout(placeable.width, placeable.height) {
        placeable.place(0, 0)
    }
}

关键不是“把尺寸藏起来”,而是**placeable.height 在测量 lambda 内部被读取和使用,没有经过组合阶段的状态读取,所以不会注册为组合依赖,也不会反过来使组合失效**。

这条边界在官方修复 fillParentSize 约束变化问题时得到了印证:fillParentSize() 知道的尺寸只在下一帧才改变,而这一帧列表已经按旧尺寸计算了滚动位置,导致位置错位;修复方向正是**“在测量阶段使用新尺寸,而不是在组合阶段”**。把它定位为“印证”而不是“依据”——它是一条具体修复记录,不是恒久 API 契约,但它指向的原则和 onSizeChanged 完全一致:测量阶段拿到的东西,应尽量在测量阶段用完;拖回组合阶段,就要承担时序错配的代价。

五、怎么在 trace 里确认“这就是测量阶段的问题”

前四节讲机制和判断。真实项目里,最有用的往往不是“理论上为什么会闪”,而是“怎么在系统 trace 里看到它”。

官方性能 codelab 给了一个直接入口:由于 Lazy composable 使用 SubcomposeLayout,它们总是分多个工作块呈现:先出容器,再出当前可见项。 你可以在系统 trace 里找到 compose:lazylist:prefetch 标记,它表示额外项正在进入视口、被提前预取。

这意味着两件事。第一,“测量中组合”不是纯理论,它在 Perfetto 或 Android Studio profiler 里是有形状的:容器和项不是一次组合完成,而是分块出现。第二,如果你怀疑闪烁和测量阶段有关,可以先在 trace 里确认 Lazy 的项是否确实在测量阶段被组合、是否出现预取工作块,而不是一上来就盯着代码猜。

另外三条快速判断仍然有效:闪烁是否和滚动同步出现(不动就不闪,一动就闪);把 layoutInfo 的读取移出组合正文后现象是否消失;把 onSizeChanged 的写入临时去掉后现象是否消失。这四条不能覆盖所有情况,但能把“看起来像测量问题”和“确实是测量问题”分开。

六、决策框架:什么时候可以信任测量阶段的产物

第一问:这个值是在组合阶段读的,还是在测量/绘制阶段读的? 组合阶段读 layoutInfo,官方明确要求避免;测量阶段读,才是它的自然位置。

第二问:这个值是“锚”还是“产物”? firstVisibleItemIndex 是测量完成后的锚,官方建议包装后使用;layoutInfo 是测量本身的产物,官方要求“避免在组合中使用”。

第三问:有没有在测量/布局阶段写一个组合阶段读的状态? onSizeChanged、自定义 LayoutModifier 的测量回调,如果写入了组合阶段读的状态,就是向后写入。官方对照表里这一格写的是“否”。

第四问:这个尺寸/约束变化,会不会在帧与帧之间造成组合阶段和测量阶段看到不同版本? 如果组合阶段依赖的尺寸可能滞后于测量阶段的真实尺寸,优先用 Layout 在测量阶段统一决定。

四问串成判断路径:

flowchart TD
  A["需要读取/写入 Lazy 相关值"] --> B{"读取发生在组合阶段吗?"}
  B -->|"是:layoutInfo"| X1["高风险:避免组合直接读;改用 derivedStateOf / snapshotFlow"]
  B -->|"是:firstVisibleItemIndex"| X2["建议包装:derivedStateOf / snapshotFlow"]
  B -->|"否:测量/绘制阶段"| C{"是否在测量/布局阶段写、组合阶段读?"}
  C -->|"是"| X3["向后写入:改为在测量阶段消费"]
  C -->|"否"| D{"组合与测量是否看到不同版本尺寸?"}
  D -->|"是"| X4["用 Layout 在测量阶段统一决定"]
  D -->|"否"| X5["当前写法可接受"]

七、习题:8 道测量边界检验

第 1 题(选择)

LazyColumn 需要在测量阶段才知道哪些项可见,因此它内部使用的布局基元是:

A. Layout
B. SubcomposeLayout
C. Box
D. Row

参考答案:B。

解读: SubcomposeLayout 允许在测量过程中调用 subcompose 组合内容,这正是 LazyColumn 实现“按可用空间决定组合哪些项”的基础。普通 Layout 的 measure policy 拿到的是一组已经组合好的 Measurable,没法在测量中途追加组合。

第 2 题(判断)

LazyListState.layoutInfo 可以在组合阶段直接读取,它的值在滚动过程中保持稳定。

参考答案:错。

解读: 官方 API 参考明确:layoutInfo 在每次滚动或重新测量之后都会更新;如果在组合函数中使用,每次变化都会触发重组,可能导致性能问题,包括无限重组循环;因此应避免在组合中使用。它需要被 derivedStateOf 压缩,或通过 snapshotFlow 桥接。

第 3 题(简答)

为什么把 LazyColumn 放进一个需要 intrinsic 测量的容器里会崩溃?

参考答案: 因为 SubcomposeLayout 不支持 intrinsic measurement。官方异常信息明确指出,这包括 lazy lists、BoxWithConstraints、TabRow 等所有建立在 SubcomposeLayout 之上的组件。常见现场是父级用 IntrinsicSize 之类的方式向 LazyColumn 发起 intrinsic 查询;归因要落在“谁在问 intrinsic”,而不是某个 modifier 自身“触发了 intrinsic”。

第 4 题(代码分析)

下面代码在滚动中出现了高频重组,原因是什么?如何修改?

val listState = rememberLazyListState()
LazyColumn(state = listState) { /* ... */ }

val lastVisible = listState.layoutInfo.visibleItemsInfo.lastOrNull()
Text("last: ${lastVisible?.index}")

参考答案: listState.layoutInfo 在组合正文里被直接读取,而它在滚动中每次测量都可能变化,导致 Text 所在的组合位置按测量频率重组。官方 API 参考把这种用法列为“避免在组合中使用”,因为它可能引发包括无限循环在内的性能问题。修改方向:用 derivedStateOf 把 layoutInfo 压缩成低频布尔值,或通过 snapshotFlow 放进 LaunchedEffect。

第 5 题(判断)

Modifier.onSizeChanged 在布局阶段写入一个状态,只要这个状态不在组合阶段被读取,就不会引起向后写入。

参考答案:对。

解读: 向后写入的条件是“较晚阶段写入、较早阶段读取”。如果写入的状态只在测量或绘制阶段被消费,组合阶段完全不碰它,就不存在更早阶段的依赖,也就不构成向后写入。但要注意:这个状态本身仍会触发它所在读取位置的失效,只是失效范围限于测量/绘制,不会倒灌回组合。

第 6 题(简答)

一个项的尺寸依赖于父级约束,而父级约束在帧之间变化。为什么可能出现“第一帧位置不对,第二帧才修正”?修复方向是什么?

参考答案: 如果项在组合阶段读取了一个尺寸相关的值,而该值在测量阶段才被父级约束更新,那么组合阶段拿到旧尺寸,测量阶段拿到新尺寸。滚动位置按旧尺寸计算,下一帧才被纠正。fillParentSize 的官方修复记录印证了这条因果链,修复方式是**“在测量阶段使用新尺寸,而不是在组合阶段”**。

第 7 题(选择)

关于 LazyListState 字段的可靠性,下列说法正确的是:

A. firstVisibleItemIndex 和 layoutInfo 都适合在组合阶段直接读
B. firstVisibleItemIndex 官方建议包装后使用,layoutInfo 官方要求“避免在组合中使用”,后者可能引发无限重组循环
C. layoutInfo 只在首次组合时变化一次
D. 两者都只在滚动停止后更新

参考答案:B。

解读: 官方 API 参考对两个字段的措辞力度不同:firstVisibleItemIndex 是“有重组代价,建议用 snapshotFlow 或 derivedStateOf 包装”;layoutInfo 是“避免在组合中使用”,并明确点名“无限重组循环”。两者不是同一类状态,读取策略也不能相同。

第 8 题(综合简答)

有人说:“LazyColumn 的测量跟普通 Column 一样,只是它少组合了一些项。”这个说法忽略了什么?

参考答案: 它忽略了 LazyColumn 反转了组合和测量的顺序。普通 Column 先组合全部子项,再测量;LazyColumn 先拿到约束,再在测量过程中 subcompose 需要显示的项。这意味着项的测量可能发生在组合阶段之外、可能多次发生,SubcomposeLayout 也因此不支持 intrinsic 测量,并且这个限制适用于 BoxWithConstraints、TabRow 等所有基于 SubcomposeLayout 的组件。这个顺序反转不是“少组合几项”的优化细节,它改变了测量阶段可以做什么、不可以做什么。

八、本节课知识点总结

SubcomposeLayout 的反转与影响范围。 LazyColumn 不能在组合阶段知道哪些项可见,因此用 SubcomposeLayout 在测量过程中 subcompose 内容。测量不再只是对既定组合树求尺寸,而是“一边决定组合什么,一边测量”。这条机制不只影响 LazyColumn:BoxWithConstraints、TabRow 等所有建立在 SubcomposeLayout 之上的组件共享同一套测量边界。

intrinsic 测量的放弃。 SubcomposeLayout 不支持 intrinsic measurement,因为它的内容组合依赖约束,与“先问尺寸、再给约束”的 intrinsic 时序互斥。把 LazyColumn 放进需要 intrinsic 查询的容器,会得到 IllegalStateException。归因要说准:是“有东西向 LazyColumn 问 intrinsic”,不是某个 modifier 自己“触发了 intrinsic”。

LazyListState 的可靠性分级。 firstVisibleItemIndex / firstVisibleItemScrollOffset 的官方措辞是“有重组代价,建议用 snapshotFlow 或 derivedStateOf 包装”。layoutInfo 的官方措辞是“避免在组合中使用”,并明确点名“无限重组循环”。前者是“建议包装”,后者是“禁止直接读”,分级不能混为一谈。

向后写入的官方判定。 官方对照表明确把“组合 → 布局(onSizeChanged、LayoutModifier)”标记为“否 - 反向写入”,原因是“布局使 Composition 失效 → Recomposition 循环”。后果包括首帧闪烁、额外帧和无限重组循环。修复方向是让尺寸在测量阶段消费,比如在 Layout 的测量 lambda 内部直接读取 placeable.height,不写回任何组合状态。fillParentSize 的修复记录是这条边界的“印证”,不是“依据”。

trace 诊断入口。 Lazy composable 因为 SubcomposeLayout,总是分多个工作块呈现:先容器,再当前可见项;系统 trace 里可以找到 compose:lazylist:prefetch,表示额外项正在预取。这是“测量中组合”在生产环境中的可观测形状。

一句话收束: 第9课回答“状态在回收中归谁管”,这一课回答“测量本身在时间中是什么形态”。LazyColumn 的测量不是一次性快照,而是一个可能多次发生、可能中途决定组合内容的动态过程。测量阶段的产物,在测量阶段消费;拖回组合阶段,就是在和时序错配打交道。

九、下期预告

第11课:LazyList 的滚动与动画边界——scrollToItem、animateScrollToItem 与“为什么滚动动画和状态恢复会打架”

第9课讲状态归谁管,第10课讲测量在时间中的形态。这两条边界交汇的地方,是滚动本身。

scrollToItem 是同步的,它立刻改变滚动位置;animateScrollToItem 是异步的,它启动一个滚动动画,位置在一段时间内连续变化。但两者都要面对同一个问题:滚动位置是一个会跨配置变更、跨进程死亡恢复的状态,而动画是一个有时序、可被打断的过程。当恢复逻辑在动画运行中触发,或者动画在项被回收时启动,会发生什么?

下一课拆三件事:scrollToItem 与 animateScrollToItem 在“位置更新”上的时序差异;滚动位置作为可恢复状态时,恢复与动画的竞态边界;以及为什么“在 LaunchedEffect 里调 animateScrollToItem”这个看似标准的写法,在某些组合身份变化下会表现反常。第10课讲的是测量在时间中的边界,第11课讲的是滚动在时间中的边界。下期见。