从 RN 首页插入越界到 Android ART:一次 32 位预创建任务丢失的排查

5 阅读23分钟

现象: RN 首页偶发 addViewAt 插入越界,线上样本集中在 Android 12 的 32 位进程。

根因链: ConcurrentLinkedQueue(下称 CLQ)跳过预创建任务 → C++ 去重后不再下发 Create → ViewState 缺失 → 后续插入越界;底层表现与官方 ART ARM32 对象 CAS 慢路径缺陷高度吻合。

规避: 仅在 Android 12 / 12L 的 32 位进程中,将 preMountItems 换成 LinkedBlockingQueue,通过自编译 RN AAR 随 APK / AAB 发版。

本文基于React Native 0.86.3 和 Fabric 的一次排查。我们遇到的这批首页崩溃,业务页面和数据看不出明显异常,部分设备是 Android Go,常用的 64 位测试机又很难复现。

最开始,我们怀疑过组件更新、列表裁剪、动画和 RN 挂载顺序。沿着节点生命周期往上查,才发现:插入越界只是最后的结果,更早发生的是预创建任务没有交付给执行端。 把队列从业务中独立出来测试,问题依然存在。

下面重点讲清楚:正常的 Home 渲染如何进入系统队列,GC 和 ARM 独占写入如何暴露寄存器复用缺陷,以及这个错误怎样逐层传导成首页越界。

先说明证据边界:队列任务未交付和 RN 后续失效链有直接记录;官方 CAS 缺陷与实测高度吻合,但我们没有抓到对应 CAS 的寄存器现场,也未将设备的 ART 二进制逐指令匹配到官方缺陷版本。 下文的地址和汇编过程是源码机制说明,不是现场指令回放。

一、先从真正复现的异常说起

我们使用 Redmi A1+、Android 12 Go、32 位进程,在已登录的 SIT Home 中复现了问题。

第一次有效复现保留了原 SIT 包的业务 Bundle 和全部 53 个原生库,只增加 Java 层诊断。操作是冷启动后等待首页加载,再进行首页滑动。这证明业务场景能够触发问题,但还不能证明“滑动”或某个业务模块是必要条件;诊断本身也存在时序开销。

最终异常是:

IllegalStateException:
addViewAt: failed to insert view [544] into parent [584] at index 4

Caused by:
IndexOutOfBoundsException: index=4 count=3

如果只看这段栈,会认为 544 的插入位置算错了。但把这一批挂载记录展开,顺序是:

挂载操作结果父容器实际子节点数
插入 536,index=0成功1
插入 532,index=1成功2
插入 534,index=2成功3
插入 542,index=3找不到 ViewState,RN 提前返回3
插入 544,index=4index 超过实际 childCount,崩溃3

关键不在最后一行,而在倒数第二行:542 根本没有对应的 Java 节点,所以它没有被插进去。

RN 后续仍使用完整树计算出来的索引。它预期前面已经有 4 个子节点,但 Android 容器里实际只有 3 个,于是下一次插入越界。

这也说明,简单捕获异常、跳过插入,或者把 index 强行改成 childCount,都没有解决源头。节点缺失已经发生,继续执行可能只是把 Crash 变成缺图、错位或后续挂载异常。

二、先分清 RN 的四种“节点”和两条创建路径

这次排查中,最容易混淆的是“节点已经创建”到底指哪一层。

对象所在位置含义
ShadowNodeC++描述组件、属性和布局的节点,不是 Android View
PreAllocateViewMountItemJava 堆一份“创建 View”的任务,构造它不代表已经创建 View
CLQ 的 NodeJava 堆队列内部的链表节点,负责保存任务引用
ViewState / Android ViewJava / Android UI 层任务执行后真正登记、创建的节点与视图

RN 还同时存在两条创建路径:

路径 A:预创建
ShadowNode 生成
  → C++ 安排预创建、登记 tag
  → JNI 调用 Java
  → 生成 PreAllocateViewMountItem 并入队
  → UI 线程取出任务、执行
  → 创建真实 View

路径 B:正式挂载
ShadowTree 提交、计算差异
  → 产生 Create / Insert 等变更
  → C++ 检查 tag 是否已登记
  → 未登记才下发 Create
  → Java 执行后续 Insert

两条路径可能交错。预创建的作用,是把一部分 View 创建工作提前处理,降低正式挂载时的集中开销。

2.1 为什么是 C++ 先登记?

创建 ShadowNode 后,C++ 的调用链会经过:

UIManager::createNode
  → Scheduler::uiManagerDidCreateShadowNode
  → FabricUIManagerBinding::schedulerDidRequestPreliminaryViewAllocation
  → FabricMountingManager::maybePreallocateShadowNode

节点先进入 C++ 的预创建请求容器。后续 drainPreallocateViewsQueue() 取出请求,调用 preallocateShadowView()。

这里的 C++ 容器是加锁保护的 vector,不是后面发生异常的 Java ConcurrentLinkedQueue。

preallocateShadowView() 的关键逻辑可以简化为:

// 机制示意,省略 surface、props、state 等参数。
lock(allocatedViewsMutex);

if (allocatedViewRegistry.contains(tag)) {
    unlock(allocatedViewsMutex);
    return;
}

allocatedViewRegistry.insert(tag);
unlock(allocatedViewsMutex);

callJavaPreallocateView(tag);

为什么先登记?因为正式挂载路径也可能准备创建同一个节点。两条路径共用登记表,避免重复安排创建:

  • 预创建先登记,正式挂载就不再下发重复 Create。
  • 正式挂载先登记,后来的预创建请求就返回。

所以,虽然名字叫 allocatedViewRegistry,这里的登记并不是“Java 创建成功”的回执,更准确的语义是:

这个 tag 的创建工作已经安排,不要重复安排。

它包含了“已经安排,但尚未执行”的状态。

2.2 JNI 返回,为什么不等于 View 已创建?

C++ 调用的是 FabricUIManager.preallocateView()。这个 Java 方法只做两件事:构造任务、加入队列。

FabricUIManager.preallocateView
  → MountItemFactory.createPreAllocateViewMountItem
  → 构造 PreAllocateViewMountItem
  → MountItemDispatcher.addPreAllocateMountItem
  → preMountItems.add(task)
  → 返回

真正创建 View,要等 UI 线程走到另一段:

preMountItems.poll()
  → PreAllocateViewMountItem.execute()
  → SurfaceMountingManager.preallocateView()
  → createViewUnsafe()
  → 创建并登记 ViewState
  → ViewManager.createView()

这里有两个同名的 preallocateView:

  • FabricUIManager 里的方法负责接收、入队。
  • SurfaceMountingManager 里的方法才负责实际创建。

JNI 调用本身同步返回,但它调用的 Java 方法只是安排了延后执行的任务。 因此,JNI 返回只能证明入队入口执行完了,不能证明 execute() 或 createViewUnsafe() 已经执行。

2.3 正式 Create 为什么没有补上这个节点?

正式 Create 不是由 createViewUnsafe() 回调给 C++ 的,而是来自另一条 ShadowTree 提交、diff、挂载路径。

FabricMountingManager::executeMount() 遇到 Create 变更时,逻辑可以简化为:

if (!allocatedViewTags.contains(tag)) {
    enqueueCreateInstruction(tag);
    allocatedViewTags.insert(tag);
}

如果预创建已经登记,正式 Create 就被过滤。但 Insert 仍然需要执行:创建 View 和把 View 插入父容器是两件事。

正常情况下,Java 调度器会优先处理预创建任务,再执行普通挂载任务。这个设计依赖一个前提:已经可靠入队的预创建任务不能无故丢失。

这次被打破的就是这个前提。

三、从“没创建”继续追到“任务已入队,但没有被取出”

只看到 ViewState 缺失还不够。它可能是没创建、创建后被删除,也可能是任务还在等待。

我们继续补齐 C++ 登记、JNI 入口、任务构造、队列入队/出队以及 Java 创建/删除的记录,并用独立的普通 Fabric View 树替换场景放大概率。

在其中一次完整记录中,目标是 tag=408:

环节记录结果
C++ 收到预创建请求有
C++ 登记 tag=408有
Java 构造对应任务对象有
对应任务加入 preMountItems有
JNI 正常返回有
poll 返回这个任务没有
这个任务执行 execute没有
Java 创建或删除对应 ViewState没有
正式挂载处理 Create发现已登记,过滤 Create

同一窗口内,队列入队 454 次、出队 453 次。408 前后的 406、410、412 都被取出,408 没有。目标任务由对象 identity 关联,记录序号连续,该次窗口从记录起点完整保留,没有诊断事件丢失。

随后又在两个独立进程中捕获了同类链路。这三次来自真实 Fabric 最小用例,不是线上 Home 回放;其中一次没有额外 GC 压力线程,但仍可能发生正常 GC。

第一次 Home 中的 542 与这里的 408 属于不同运行。前者没有完整的上游队列记录,不能把后一次证据当作前一次的指令回放。

如第二节所述,C++ 不会为已登记的节点补发 Create。这组记录把断点继续前移到了:任务已经入队,却没有被取出交给执行端。

四、为什么系统队列没有交付这个任务?

到这里,排查重点从 RN 视图插入转向了系统队列和 ART。只关心规避方案,可以直接看第十节;想理解底层机制,继续往下。 第五至七节补齐 GC、对象引用和 ARM 指令的基础,第八、九节把失效链串起来。

我们又把 RN 和 Home 业务拿掉,只测系统的 ConcurrentLinkedQueue。

独立程序使用递增任务 ID,核对每一个入队和出队元素;通过受控堆大小和对象分配压力放大问题概率。这是测试条件,不代表线上用户一定处于同等压力。

对照方式结果
CLQ,默认 ART 执行,三轮各入队 200 万个元素分别丢失 1、3、3 个
LinkedBlockingQueue,默认 ART 执行,两轮各入队 200 万个元素两轮都未观察到丢失
CLQ,解释执行模式,两轮各入队 200 万个元素两轮都未观察到丢失
单个线程分批入队、再出队,使用 CLQ入队 2,000,896 个,出队 2,000,866 个,少了 30 个

最后一组很关键:业务上不需要两个消费者竞争,同一线程先放、后取也能出现问题。 同时,切换到解释执行的对照结果,进一步支持问题与 ART 的优化编译执行路径相关。

这时排查重点已经不再是 Home 的组件 key 或数组下标,而是系统队列依赖的底层原子操作。

Android 12 的 CLQ 使用对象 CAS 来领取任务。可以用下面的伪代码理解:

读取当前队列节点 p.item

如果 item 非空,而且 CAS(p.item, item, null) 成功:
    领取这个任务
    必要时推进队头
    返回任务
否则:
    继续检查下一个队列节点

CAS 修改的是队列节点中的任务引用,不是任务内部数据,更不是 C++ 的 ShadowNode。Android 12 CLQ 源码

把它接回原来的业务场景,完整入口是:

Home 正常渲染卡片、图标等组件
  → Fabric 安排对应节点的预创建
  → Java 分配任务对象和队列节点
  → UI 线程 poll 领取任务
  → 队列调用对象 CAS(比较并交换)
  → ART 执行相应的 ARM32 编译代码

页面创建任务、队列节点和 View,会带来正常的 Java 堆分配,这些操作可能与 GC 重叠。这里不是 JS 直接调用了 ARM 指令,也不要求业务出现内存泄漏或 OOM。问题涉及 ART 管理的 Java 堆,不是 Hermes 的 JS 堆。

对象分配多、队列操作频繁,只是增加遇到相关执行条件的机会;不能据此反推某张卡片一定触发了 GC,更不能把低端机或某次滑动当作独立根因。

接下来需要把这次涉及的 GC 和 ARM 机制分开看。

五、GC 为什么会让同一个对象出现新旧两个引用?

5.1 GC 不只是回收垃圾,也会搬动活对象

ART 的 Concurrent Copying GC 会复制、整理仍然存活的 Java 对象。因此,一个还在队列中的任务也可能从旧位置搬到新位置。这不代表任务被删除,也不代表业务中出现了两个任务。AOSP GC 说明

假设任务 B 搬家:

任务 B 原来的位置:0x1000
任务 B 搬家后位置:0x9000

这里说的是 Java 堆中的任务对象。RN 的 tag 仍然是同一个逻辑 ID,C++ 的 ShadowNode 也不是被这次 Java GC 搬动的对象。

5.2 字段地址和字段保存的内容,不是一回事

假设队列节点中的 p.item 字段位于 0x5000:

0x5000:p.item 这个字段所在的位置
0x1000:p.item 当前保存的对象引用
0x9000:任务对象搬家后的新位置

为了便于说明,后文暂不展开队列节点 p 自身也可能移动的情况,并省略引用编码、堆投毒等实现细节。

并发 GC 期间可能短暂出现这样的状态:

字段 p.item
位于 0x5000,内容仍为 0x1000
                 │
                 ▼
任务旧位置 0x1000
保存 GC 转发信息 ───────────→ 任务新位置 0x9000

程序读取 p.item 时,经过读屏障,拿到 0x9000

对象已经搬家,不代表堆里的所有引用在同一瞬间都改写完。GC 和业务线程并发工作时,运行时需要保证程序拿到的引用仍然有效。

5.3 读屏障怎样知道它们是同一个对象?

可以把这里的读屏障理解成:运行时在对象引用读取过程中插入的一段检查、修正逻辑。

遇到旧引用时,它根据 GC 的转发信息找到新位置。不是调用 equals(),不是比较 tag,也不是猜测两块内存内容是否一样。

Android 12 的 ConcurrentCopying::Mark() 遇到 from-space 对象时,会查询转发引用;必要时完成复制,返回对应的新引用。GC 转发源码

所以,下面两个状态可以同时成立:

堆中字段 p.item 的原始内容:0x1000
程序经过读屏障拿到的引用:0x9000

它们描述的是同一个逻辑对象。读屏障也不意味着此时一定已经把原字段同步改写成新引用。

这里的读屏障不是锁,也不要与 CPU 的内存顺序栅栏混为一谈。它解决的是 GC 搬动对象之后的引用正确性。

六、对象 CAS 为什么必须同时记住新旧两个引用?

队列领取任务的逻辑是:

// 语义示意。
Object expected = p.item;
compareAndSwapObject(p, ITEM_OFFSET, expected, null);

第一步,普通对象读取经过读屏障,程序拿到的新引用是:

expected = 0x9000

第二步,CAS 底层检查字段原始内容,可能仍然读到:

p.item = 0x1000

如果只比较数字,会发现 0x1000 != 0x9000。但它们实际上指向同一个逻辑对象,不能直接判定为“任务已经被别人改掉了”。

因此 ART 要进入对象 CAS 的读屏障慢路径:确认旧引用经 GC 处理后,确实对应调用者期待的新引用,再继续原子更新。

这里的“慢路径”只是处理特殊情况的代码分支,不是接口超时或页面卡顿。

确认完成后,需要保存两个比较依据:

expected  = 0x9000  // 期待对象的新引用
old_value = 0x1000  // 已确认属于同一对象的旧引用

后续尝试时,字段读到旧引用或新引用,都可能仍然是这个任务。但如果变成另一个对象的引用,例如 0xA000,就应该判定比较失败。

不能在每次重试时,都把“刚读到的任何值”当成新的预期值。 否则就可能覆盖其他线程真正改进去的对象。

因此,最初确认过的旧引用需要跨重试保留。ART 源码中的慢路径正是同时保留新引用和已确认的旧引用来比较。Android 12 ART CAS 实现

七、补一点 ARM 基础:独占写入失败为什么是正常现象?

7.1 寄存器只是 CPU 内部的临时存储位置

ARM32 通用寄存器保存的是 32 位数据。某一时刻可以保存地址,另一时刻可以保存计数或返回状态。对 CPU 而言,首先都是二进制位;具体含义由指令和程序逻辑决定。Arm AArch32 寄存器说明

ART 源码中的 tmp、out 是代码生成器中的名字,并不是 CPU 上真的存在同名寄存器。它们最终会对应具体的硬件寄存器。

复用寄存器本身没问题,前提是之前保存的内容后续已经不再需要。

7.2 LDREX 和 STREX 各做什么?

普通的“先读、比较、再写”不能保证原子性,因为比较和写入之间,其他线程可能修改目标字段。

这里的 ARM32 CAS 实现会用到一对独占读写指令,概念上是:

LDREX rRead, [rAddr]          ; 读取目标位置,建立独占监视记录
STREX rStatus, rNew, [rAddr]  ; 条件满足才写入,并返回状态

上述寄存器名用于解释用途,不是完整生产汇编;内存顺序处理等细节也未展开。

“独占”不是把整块内存锁住、不让其他线程访问,而是让 CPU 判断后面的条件写入是否可以完成。

STREX 将结果写入状态寄存器:

状态意义
0本次写入成功
1本次写入未完成,需要重新尝试

这是独占写入指令的状态,不是 Java CAS 最终返回的布尔值。写入状态 0 对应“写成了”,最终 CAS 才能返回 true;写入状态 1 通常应进入重试,而不是直接返回 false。

这是 ARM 指令正常定义的两种结果。Arm STREX 说明

7.3 为什么没有其他消费者,写入也可能失败?

独占监视状态可能因为上下文切换等原因失效。架构也允许某些实现条件使独占监视失效,并不要求一定有业务线程改写了目标字段。Arm 架构手册 A3.4.4–A3.4.5

例如:

当前线程完成 LDREX
  → 线程被系统暂时调度出去,独占监视记录失效
  → 线程恢复
  → 字段内容实际没有变化
  → STREX 仍可以拒绝这次写入,返回 1

所以必须区分两件事:

  • STREX 未写成:这一次尝试需要重试。
  • CAS 对象比较失败:目标已不再是期待的对象,可以向调用者返回 false。

这两种失败不能混在一起。强 CAS 需要在内部消化独占写入重试,而不能把一次正常的底层重试误报为对象已经不匹配。

八、官方 bug:写入结果覆盖了下一轮还要用的旧引用

这一节解释 CAS 为什么会错误返回 false,第九节再解释它怎样变成任务跳过。不看指令细节,也可以先读 8.2 的三个误区,再看第九节的完整链路。

现在把 GC 和独占写入放到同一次执行里。

假设已经进入读屏障慢路径,并确认两个引用对应同一个任务:

p.item 的原始内容 = 0x1000
expected          = 0x9000
old_value         = 0x1000
准备写入的新值    = null

ART 需要保存旧引用供后续比较,还需要一个寄存器接收独占写入状态。有缺陷的实现却把这两个用途放在同一个寄存器中:

old_value     → tmp
store_result  → tmp

问题就在于:旧引用不是只用一次。独占写入失败后,下一轮重试还需要它。

8.1 一次具体的失败过程

步骤内存字段 p.itemtmp 内容执行情况
1. 准备尝试0x10000x1000正确保存旧引用
2. 独占读取并比较0x10000x1000与已确认的旧引用匹配
3. 独占写入未完成0x10001STREX 将结果写入 tmp,覆盖旧引用
4. 进入重试0x10001原本需要的 0x1000 已丢失
5. 再次比较0x10001比较依据错误,返回 CAS false

第 5 步仍把 tmp 当作保存 old_value 的寄存器:当前字段值必须等于 expected(0x9000),或等于 tmp 中的旧引用。 但 tmp 已被覆盖为 1,字段值 0x1000 与两者都不匹配,于是误判失败。

正常的第五步应该是:

当前字段值 0x1000

等于新引用 0x9000?否
等于旧引用 0x1000?是

→ 继续尝试写入

发生 bug 后却变成:

当前字段值 0x1000

等于新引用 0x9000?否
等于被覆盖后的“旧引用”1?否

→ 错误地认定对象不匹配

这里不是 CPU 把两次正常写入弄乱了,而是 ART 生成的机器码没有正确保留跨重试仍然存活的数据。

8.2 三个容易误解的地方

第一,STREX 失败没有把 p.item 写成 1。

1 写入的是状态寄存器,内存字段仍然是 0x1000。任务对象本身也没有因此被篡改。

第二,这里不一定立即发生非法地址异常。

CPU 只是比较数字 0x1000 和 1,并没有把 1 当作地址访问。因此错误先表现为 CAS 返回值错误,之后才逐层传导成业务异常。

第三,GC 和独占写入重试是两个条件,不要求重试一定由 GC 造成。

GC 让这次 CAS 需要同时处理新旧引用;调度或其他符合架构规定的情况让独占写入需要重试。两者在有缺陷的慢路径中相遇,才暴露出寄存器覆盖问题。

8.3 官方具体修了什么?

AOSP 的 ARM: Fix CASObject intrinsic slow path 修复了这个问题。

关键调整是:

修复前:
old_value     → tmp
store_result  → tmp

修复后:
old_value     → tmp
store_result  → out

旧引用保留在 tmp 中,写入结果使用另一个合适的临时位置,下一轮比较就不会丢失依据。

因为 out 同时还参与中间结果和最终布尔返回值的保存,官方也调整了顺序:先判断写入结果,再复用寄存器保存成功值,并增加寄存器冲突检查。官方修复 diff

修复针对的是 ART 的 ARM32 代码生成逻辑,不是修改 CLQ 的 Java 源码,也不是给 RN 的 addViewAt 加保护。

九、为什么一个 CAS false 会让队列跳过任务?

这里说的“丢”,是指任务没有被正常消费路径交付,不是 CAS 删除了任务对象。队头继续推进后,节点可能不再从队头可达,也不能理解成“它一直留在队列里,下一帧就会被取到”。

从 CLQ 的角度看,底层强 CAS 返回 false,意味着它不能领取当前对象,于是继续检查后面的节点。

假设队列为:

任务 A → 任务 B → 任务 C

如果领取 B 时出现上述错误:

B 的 CAS 错误返回 false
  → CLQ 继续检查 C
  → 成功领取 C
  → 推进队头
  → B 可能被越过去,之后再也没有返回给 RN

RN 不知道底层 CAS 出了错,只看到已经入队的任务没有被返回。结合第二节的 Create 去重逻辑,完整失效链是:

对象 CAS 错误返回 false
  → Java 预创建任务被跳过
  → 任务 execute 没执行
  → Java ViewState 没创建
  → C++ 不再补发 Create
  → 缺失节点插入被跳过
  → 后续节点沿用完整树索引
  → addViewAt 越界

这也解释了为什么线上看起来像“首页组件偶发插入错误”,而真正要处理的位置却在预创建队列。

本节的 CAS 触发过程是基于官方源码的机制解释;实测的队列缺口和 RN 失效记录见第三、四节。

十、我们的规避方案:自编译 RN AAR,只替换预创建队列

系统 ART 的缺陷不能随业务 Bundle 一起修复。我们计划通过自编译 RN AAR 交付应用侧规避:基于当前相同版本的 RN 源码,只调整 MountItemDispatcher 的 preMountItems 初始化,不在本次修复中扩大 RN 升级范围。

本次核对的 RN 0.86.3 中,com.facebook.react.fabric.mounting.MountItemDispatcher 由 Kotlin 实现,源码文件是 MountItemDispatcher.kt。修改点就是 preMountItems 的初始化处,以下为等价逻辑示意:

import java.util.concurrent.LinkedBlockingQueue

private val preMountItems: Queue<MountItem> =
    if (android.os.Build.VERSION.SDK_INT in 31..32 &&
        !android.os.Process.is64Bit()) {
        LinkedBlockingQueue()
    } else {
        ConcurrentLinkedQueue()
    }

范围限定为 Android 12 / 12L,也就是 SDK 31 / 32,且当前进程为 32 位。判断的是实际进程位数,不是手机是否具备 64 位 CPU,也不是根据 Android Go 或机型名称判断。

其他内容不改:

  • 不改 Home 业务代码、组件结构或 JS key。
  • 不关闭 Fabric 预创建,不改 C++ Create 去重。
  • 不改挂载指令顺序,不吞异常,不修正 index。
  • 不替换另外两条 mountItems、viewCommandMountItems 队列。
  • 其他系统版本和 64 位进程继续使用原队列。

为什么 LinkedBlockingQueue 能规避?

它通过消费锁保护链表摘除,不依赖 CLQ 那种“对象 CAS 领取当前 item,失败就向后跳”的消费路径。因此可以避开本次直接观察到的任务丢失机制。LinkedBlockingQueue 源码

这不等于它内部完全没有 CAS,也不是“加锁就不发生 GC”。我们替换的是这条具体的消费算法。

add() / poll() 不会像 put() / take() 那样等待容量或新元素,但内部仍可能存在锁竞争,所以不能宣称完全没有性能成本。

AAR 交付需要确认什么?

自编译 AAR 是本文采用的交付方案,不能只修改 node_modules 中的 Kotlin 文件就认为已经生效。需要保持 RN 版本、依赖和 ABI 配置匹配,明确替换原 react-android 依赖,检查最终 APK 的 DEX,并在真机确认实际队列类型。

这个修复需要重新发布 APK / AAB,不能通过 JS 热更新生效。 自编译产物也要同步归档对应的符号与构建信息。

已有对照验证的是等价的单队列替换方案;自编译 AAR 作为正式交付方式,仍需完成自己的最终产物验收,不能把另一种构建方式下的结果直接当成该 AAR 已验收。

十一、这次排查留下的几点经验

  • 找第一个状态偏差,不只看最后的异常栈。 这次崩在 544,缺的是 542,断点最终前移到了队列消费。
  • 任务的生命周期要分段取证。 构造、入队、取出、执行和真实 View 创建,不能相互替代。
  • 低概率问题要逐层缩小实验范围。 Home、Fabric 最小用例、独立队列程序分别回答不同问题,不能混写成同一次复现。
  • 标准库的正确性也依赖运行时。 GC 搬对象、独占写入重试本身都正常;错误的机器码仍可能把它们组合成业务故障。

这次我们要恢复的是预创建任务的可靠交付,而不是给最后一次越界加一个保护。