现象: 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=4 | index 超过实际 childCount,崩溃 | 3 |
关键不在最后一行,而在倒数第二行:542 根本没有对应的 Java 节点,所以它没有被插进去。
RN 后续仍使用完整树计算出来的索引。它预期前面已经有 4 个子节点,但 Android 容器里实际只有 3 个,于是下一次插入越界。
这也说明,简单捕获异常、跳过插入,或者把 index 强行改成 childCount,都没有解决源头。节点缺失已经发生,继续执行可能只是把 Crash 变成缺图、错位或后续挂载异常。
二、先分清 RN 的四种“节点”和两条创建路径
这次排查中,最容易混淆的是“节点已经创建”到底指哪一层。
| 对象 | 所在位置 | 含义 |
|---|---|---|
| ShadowNode | C++ | 描述组件、属性和布局的节点,不是 Android View |
| PreAllocateViewMountItem | Java 堆 | 一份“创建 View”的任务,构造它不代表已经创建 View |
| CLQ 的 Node | Java 堆 | 队列内部的链表节点,负责保存任务引用 |
| ViewState / Android View | Java / 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.item | tmp 内容 | 执行情况 |
|---|---|---|---|
| 1. 准备尝试 | 0x1000 | 0x1000 | 正确保存旧引用 |
| 2. 独占读取并比较 | 0x1000 | 0x1000 | 与已确认的旧引用匹配 |
| 3. 独占写入未完成 | 0x1000 | 1 | STREX 将结果写入 tmp,覆盖旧引用 |
| 4. 进入重试 | 0x1000 | 1 | 原本需要的 0x1000 已丢失 |
| 5. 再次比较 | 0x1000 | 1 | 比较依据错误,返回 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 搬对象、独占写入重试本身都正常;错误的机器码仍可能把它们组合成业务故障。
这次我们要恢复的是预创建任务的可靠交付,而不是给最后一次越界加一个保护。