07.2.2.1 架构演进:Bridge、JSI 与新架构
所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native
本节要解决的问题
- 旧架构的「三线程 + 一条 Bridge」到底各自由谁执行,消息怎样排队与序列化?
- Bridge 的开销为什么在高频交互与长列表场景被放大?量化口径是什么?
- JSI 在架构中的位置是什么,它凭什么能做到同步调用,又有什么边界?
- TurboModules、Fabric、Codegen 三者如何拼成新架构,各自职责边界在哪?
- 新架构的渲染管线与线程模型改了哪些东西,为什么能支撑并发渲染?
- Bridgeless 模式、Interop 兼容层分别解决什么问题,代价是什么?
- 迁移新架构的实际步骤、判断条件与回退手段是什么?
版本前提:RN 0.76 起新架构默认开启,旧架构在后续版本被冻结(具体版本节点与兼容窗口以官方发布说明为准,标注待确认);Hermes 自 RN 0.70 起为 Android 默认引擎,iOS 默认化时间点以发布说明为准。架构能力、开关字段、CLI 命令随版本变化,凡涉及具体字段与命令处均需按项目实际版本核对。
覆盖范围
| 知识域 | 关键内容 |
|---|---|
| 旧架构机制 | 三线程模型、Bridge 消息格式、批量调度、序列化成本、典型瓶颈场景 |
| 接口层 | JSI 的 C++ 抽象、HostObject/HostFunction、引擎无关性、同步调用边界 |
| 模块体系 | TurboModules 懒加载、与旧 NativeModules 的差异、类型契约 |
| 渲染体系 | Fabric 的 ShadowNode/ShadowTree/Commit/Surface、挂载流程、并发能力 |
| 工具链 | Codegen 输入输出、构建期生成、类型契约校验 |
| 架构切换 | Bridgeless 模式、Interop 兼容层、迁移路径、验收与回退 |
题号索引
| 题号区间 | 主题 |
|---|---|
| 001-004 | 旧架构分层、Bridge 消息机制、线程模型与瓶颈来源 |
| 005-007 | JSI 的定位与同步调用,TurboModules 的懒加载与契约 |
| 008-011 | Fabric 提交流程、Codegen 产物、渲染管线与线程模型变化 |
| 012-014 | Bridgeless、并发渲染、Hermes 与架构的关系 |
| 015-018 | 迁移路径、依赖判断、Interop 代价与综合论证题 |
07.2.2.1-001 React Native 的整体架构由哪些层次组成?
一句话结论
RN 分成三层:JS 层用 React 描述界面与业务逻辑,中间是 C++ 核心(接口层、渲染器、模块调度),底层是平台原生层(Android/iOS 的视图与能力实现)。三层之间靠 JSI 或旧 Bridge 通信,最终由原生视图上屏。
概念解释
JS 层跑在独立的 JS 运行时里(Hermes 或 JSC 等),它不知道 UIView 或 android.view.View 的存在,只能操作 RN 暴露的组件与 API。C++ 核心层是新架构的主体:JSI 提供 JS 与原生的互操作能力,Fabric 负责把 React 树转成原生的 shadow tree 与挂载指令,TurboModules 负责模块注册与按需加载。平台层才是真正的实现,例如 RCTView、ReactViewGroup、原生模块的 Java/Kotlin 与 ObjC/Swift 代码。旧架构没有独立的 C++ 核心,中间层是一条 JSON 消息桥。
理解这个分层,才能回答后续所有「为什么慢」「为什么迁移要改原生代码」的问题:跨层就意味着一次边界跨越,边界越"哑"(只能传序列化消息),单位成本越高。
原理流程
JS 层:React 组件 / 业务逻辑 / 状态
↓ JSI(新)或 Bridge(旧)
C++ 核心:接口层 + Fabric 渲染器 + TurboModules 调度 + Codegen 生成的绑定
↓ 平台适配(ViewManager / MountingManager / 原生模块实现)
平台层:Android View / iOS UIView / 原生能力(相机、定位、存储)
代码或图示
旧架构:JS ──JSON 消息──▶ Bridge ──▶ 原生(无 C++ 核心层)
新架构:JS ──JSI──▶ C++ 核心(Fabric / TurboModules)──▶ 原生
常见误区
- 以为 RN 是 WebView 套壳:RN 渲染的是平台原生视图,WebView 只是可选能力之一。
- 以为 JS 层可以直接持有原生对象:跨层对象必须先被包装成 JSI 可识别的 HostObject 或经绑定生成。
追问
- C++ 核心层对业务开发意味着什么?答:意味着原生模块改造、Codegen 契约与渲染行为的变化都要从 C++ 侧对齐,而不是只改 JS。
- 为什么 RN 要把核心放到 C++?答:一套核心同时服务 Android/iOS,减少两套桥接实现的语义漂移,也让渲染与模块调度可共享。
07.2.2.1-002 旧架构 Bridge 的消息格式与批量调度机制是什么?
一句话结论
旧架构的 Bridge 是一条异步消息队列:JS 侧把调用压成 [moduleID, methodID, params] 形式的数组,攒批后序列化成字符串跨边界,原生侧反序列化后按模块表分发执行,结果再以同样方式回流。
概念解释
Bridge 有两个方向的消息队列:JS 到原生(模块调用、UI 指令)与原生到 JS(事件回调、模块回调)。消息不逐条发送,而是在 JS 事件循环一个批次结束时统一 flush,把一批消息序列化成一个字符串传给对端,对端反序列化后逐条执行。这套设计的好处是摊薄了跨边界成本,坏处是每条消息都要经过编码/解码,且天然是异步的——调用发生与执行之间存在排队延迟。
模块与方法用数字 ID 标识,模块表在启动时注册。这意味着旧架构下所有原生模块在启动阶段就要完成注册与部分初始化,模块数量直接拖慢启动。
原理流程
JS 调用 NativeModules.Foo.bar(x)
→ 压入 JS→Native 队列(moduleID, methodID, params)
→ 批次结束 flush → 序列化为字符串
→ 跨边界 → 原生反序列化 → 查模块表 → 执行
→ 结果/回调压入 Native→JS 队列 → 下一个批次回流
代码或图示
消息形态(示意):
[[3, 7, {"id": 42}], [5, 1, {"text": "hi"}]]
↑ 模块 ID ↑ 方法 ID ↑ 参数(需可序列化)
常见误区
- 以为 Bridge 是同步函数调用:调用只是入队,执行时刻不受调用方控制。
- 以为批量发送就没有成本:批量只摊薄了跨边界次数,序列化与反序列化的总量不变。
追问
- 参数为什么必须可序列化?答:跨边界只能传字符串,函数、类实例、循环引用都无法直接过桥。
- 批量调度的粒度由什么决定?答:由 JS 事件循环批次决定,一个批次内的调用合并发送,跨批次则各自排队(具体实现以版本源码为准,待确认)。
07.2.2.1-003 旧架构的三个线程各自负责什么?
一句话结论
旧架构有三个关键线程:JS 线程执行 JS 与 React 渲染,Shadow 线程用 Yoga 计算布局,主线程(UI 线程)负责真正的视图创建、更新与绘制;三者之间靠 Bridge 与调度器串联。
概念解释
JS 线程上跑的是 React 的协调过程与业务逻辑,任何长任务(大列表 diff、复杂计算、同步存储读写)都会阻塞整个 JS 队列。Shadow 线程是旧架构特有的:JS 侧提交的组件树变更被转成 shadow 节点,由 Yoga 在 Shadow 线程计算 flex 布局,产出布局结果。主线程执行 UIView / View 的创建、属性设置、插入移除与最终绘制。
跨线程是异步的,所以旧架构下从「状态变化」到「像素变化」至少要经历:JS 算完 → 消息过桥 → Shadow 算布局 → 再过桥 → 主线程挂载 → 下一帧绘制。任何一环排队,用户看到的就是掉帧。
原理流程
JS 线程:setState → React diff → 生成 UI 操作指令
↓ Bridge(异步)
Shadow 线程:构建 shadow 节点 → Yoga 计算布局
↓ Bridge(异步)
主线程:创建/更新原生视图 → 绘制 → 上屏
代码或图示
| 线程 | 旧架构职责 | 典型阻塞现象 |
|---|---|---|
| JS 线程 | JS 执行、React 渲染、业务逻辑 | 交互无响应、动画卡住 |
| Shadow 线程 | Yoga 布局计算 | 布局结果延迟、首屏慢 |
| 主线程 | 视图挂载、绘制、触摸事件 | 掉帧、滑动不跟手 |
常见误区
- 以为 JS 线程能直接改原生视图:所有 UI 操作都要经桥到主线程执行。
- 以为布局在 JS 线程算:旧架构布局在 Shadow 线程,这也是它被诟病"多一跳"的原因之一。
追问
- Shadow 线程存在的意义是什么?答:把布局计算从主线程剥离,避免布局阻塞 UI,但代价是多一次跨线程与跨边界。
- 三线程模型下如何定位卡顿?答:先分清是 JS 长任务、布局耗时还是主线程挂载/绘制,三者工具与优化手段完全不同。
07.2.2.1-004 旧架构的序列化与异步为什么成为瓶颈?
一句话结论
因为每次跨边界都要序列化+反序列化一份完整数据,且必须排队等待批次与线程切换;当单帧内跨边界次数与数据量上升(高频手势、滚动列表、动画、批量事件)时,这部分成本会直接挤占 16.7ms 的帧预算。
概念解释
瓶颈不在单次调用的绝对值,而在「次数 × 单次成本 × 排队延迟」。典型的放大场景有三类:一是滚动与手势,每帧都要把偏移量、触摸事件送过桥;二是长列表,挂载期成百上千个视图的创建指令要过桥,且要等 Shadow 线程算完布局;三是高频回调,例如传感器、动画帧回调、输入框实时校验。
序列化成本与数据结构强相关:嵌套对象、大数组、长字符串的编解码有明显开销;循环引用与函数无法过桥,还会迫使业务侧做额外转换。
原理流程
单帧预算 16.7ms
├─ JS 计算与 diff
├─ 序列化 + 排队(Bridge)
├─ Shadow 布局(Yoga)
├─ 反序列化 + 排队(Bridge)
└─ 主线程挂载与绘制
次数越多、数据越大,前四项占比越高,留给绘制的余量越小
代码或图示
优化前后对照(示意):
差:每帧 200 次跨边界小消息 → 序列化与排队成为主成本
好:合并为少量批量指令 + 关键路径走同步/原生侧计算
常见误区
- 把所有卡顿都归因于 Bridge:JS 长任务、过量视图、图片解码同样会造成掉帧。
- 以为换新架构就自动解决:新架构减少序列化中转,但视图数量、图片与业务逻辑成本依旧存在。
追问
- 如何量化 Bridge 成本?答:用 Systrace/Perfetto 观察 JS 线程与 UI 线程之外的桥接段与队列深度,结合帧耗时分布判断(工具细节以平台版本为准,待确认)。
- 旧架构下有哪些缓解手段?答:减少跨边界次数(批量 API)、把重计算下沉到原生、用原生驱动动画、控制视图数量。
07.2.2.1-005 JSI 是什么,它在架构中处于什么位置?
一句话结论
JSI(JavaScript Interface)是一套 C++ 抽象层,把 JS 引擎的能力抽象成统一接口,让 C++ 代码可以直接读写 JS 值、持有 JS 函数引用、把 C++ 对象暴露给 JS,从而绕开「只能传序列化消息」的桥。
概念解释
JSI 定义了 Runtime、Value、Object、Function、HostObject、HostFunction 等概念:HostObject 让 JS 侧拿到一个看起来像普通对象、实际由 C++ 实现属性读写的句柄;HostFunction 让 C++ 侧拿到一个可以在 C++ 里直接调用的 JS 函数。它在引擎之上做适配,Hermes、JSC、V8 都可以作为后端,所以它是「引擎无关」的。
在架构上,JSI 不是渲染器也不是模块系统,它只是接口层。Fabric 与 TurboModules 都建立在它之上:TurboModules 用它把原生方法绑定成 JS 可调用的函数,Fabric 用它把渲染指令与事件通道建立起来。
原理流程
JS 引擎(Hermes / JSC / V8)
↕ 适配
JSI(C++):Runtime / Value / Object / HostObject / HostFunction
↕ 直接调用(无消息序列化)
C++ 核心(Fabric 渲染器、TurboModules 绑定、Codegen 产物)
↕
平台原生实现
代码或图示
// 示意:C++ 侧通过 JSI 持有并调用 JS 函数(具体 API 以 RN 版本头文件为准)
jsi::Function onFrame = ...; // 从 JS 侧取得函数引用
onFrame.call(rt, jsi::Value(offset)); // 直接调用,同步返回
常见误区
- 以为 JSI 就是新架构的全部:它只是接口层,没有 Fabric/TurboModules 就没有渲染与模块体系。
- 以为 JSI 让 JS 与原生成了一件事:两者仍是不同的运行时与内存空间,跨语言调用依旧有成本,只是不再走序列化。
追问
- JSI 与旧 Bridge 最本质的差别?答:旧 Bridge 只能传字符串化的消息,JSI 能直传对象引用与函数引用,从而支持同步调用与惰性求值。
- 为什么 JSI 是 C++ 而不是平台语言?答:C++ 才能在两端共用同一套接口层,并在引擎之间做适配。
07.2.2.1-006 JSI 的同步调用能力带来什么收益与风险?
一句话结论
收益是可以同步拿到原生侧结果(例如布局测量、同步读取缓存、同步事件),省去排队与批次延迟;风险是同步调用会阻塞调用方线程,若在 JS 线程上做重活或高频同步调用,会把桥接延迟换成了卡顿。
概念解释
同步调用成立的前提是「调用发生在同一线程上下文里」。C++ 侧持有 JS 函数引用后可以在 JS 线程上直接调用它;反过来,JS 侧调用一个被 JSI 包装的原生方法时,如果实现选择同步执行,就会在 JS 线程上跑原生代码。一旦这段原生代码耗时(磁盘、锁、复杂计算),JS 线程连同 React 渲染一起被堵住。
因此新架构里同步能力是"要用的工具",不是"默认策略":像 measure 这类必须立刻拿到结果的交互适合同步,网络、存储、图片解码必须异步并回到指定线程。
原理流程
同步:JS 调用 → 直接进入原生实现 → 返回结果 → 继续执行(全程占用 JS 线程)
异步:JS 调用 → 原生实现切到工作线程 → 完成后经调度回 JS 线程 → 回调
代码或图示
| 场景 | 建议方式 | 理由 |
|---|---|---|
| 需要立即拿到布局尺寸 | 同步测量 | 依赖同一帧内的结果 |
| 网络请求、文件读写 | 异步 + 线程切换 | 避免阻塞 JS 线程 |
| 高频事件回调 | 批量/降频 + 原生侧合并 | 减少跨边界次数 |
常见误区
- 认为同步调用一定更快:单次延迟低了,但阻塞带来的尾延迟可能更高。
- 把重计算放在同步的 JSI 方法里:JS 线程被占,React 渲染与用户交互同时停摆。
追问
- 同步调用会不会造成死锁?答:如果同步路径上又等待 JS 线程回调,就可能互相等待;跨线程回调必须避免反向同步依赖。
- 如何验证同步调用是否成为瓶颈?答:看 JS 线程的长时间任务分布,同步原生耗时会在 JS 线程栈上直接可见(工具细节待确认)。
07.2.2.1-007 TurboModules 与旧 NativeModules 的差异是什么?
一句话结论
TurboModules 是按需懒加载、由 Codegen 生成类型契约的原生模块体系;旧 NativeModules 在启动时全量注册与初始化、靠手写桥接与字符串式方法表分发,二者在启动成本与类型安全上差别明显。
概念解释
旧架构下 NativeModules 在初始化阶段就要把所有模块实例化并登记到模块表,模块越多,冷启动越慢;方法调用靠数字 ID 查表,参数与返回值没有编译期约束,类型错误只能在运行时暴露。TurboModules 把这两点都改了:模块在 JS 首次访问时才创建(懒加载),方法签名由 TS 规范经 Codegen 生成 C++/平台绑定,调用直接走 JSI 函数而不是消息表。
懒加载的收益在大型 App 上最明显:几十个原生模块不必全部在启动期初始化;代价是首次访问会有一次初始化开销,需要在关键路径上做预热。
原理流程
规范:NativeFoo.ts 声明方法签名(TurboModuleRegistry)
↓ Codegen
产物:C++ 绑定 + 平台侧抽象类(Android/iOS)
↓ 运行时
JS 首次调用 → 触发模块创建(懒加载)→ 后续调用走已建立的 JSI 绑定
代码或图示
// 示意:TurboModule 的类型化规范(字段与 API 以版本为准)
import type { TurboModule } from 'react-native';
import { TurboModuleRegistry } from 'react-native';
export interface Spec extends TurboModule {
getDeviceId(): string;
}
export default TurboModuleRegistry.getEnforcing<Spec>('DeviceInfo');
常见误区
- 以为 TurboModules 需要换一套原生开发语言:原生实现仍是 Kotlin/Java 与 ObjC/Swift,变的是契约与加载方式。
- 以为所有旧模块会自动变成 TurboModule:旧模块要么走 Interop 兼容层,要么按规范重写。
追问
- 懒加载会不会让首次调用变慢?答:会,因此关键路径模块可以在启动后主动预热,把成本移出用户可感知窗口。
- TurboModules 的类型契约能拦住哪些错误?答:参数与返回类型在构建期按规范生成绑定,签名不一致会在编译/生成阶段暴露,而不是线上崩溃。
07.2.2.1-008 Fabric 渲染器的核心组成与提交流程是怎样的?
一句话结论
Fabric 是新架构的渲染器,用 C++ 维护 shadow 树:React 渲染产出新的 shadow 树并 commit,渲染器算出挂载指令(mount items),再在 UI 线程由挂载层把指令应用到真实原生视图。
概念解释
关键对象包括 ShadowNode(描述组件与属性)、ShadowTree(一棵不可变的树,commit 时整体切换)、Commit(一次树更新)、Surface(一棵树对应的挂载目标)、MountingCoordinator(把 commit 转成可执行的挂载指令)。因为是不可变树,提交天然具备"读一致性":JS 侧渲染与原生侧挂载可以在不同节奏上推进而不互相撕裂。
这套设计与旧架构最大的不同是:布局与 diff 都在 C++ 里完成,不再依赖 Shadow 线程 → Bridge → 主线程的多跳消息;挂载指令是结构化数据而不是序列化字符串。
原理流程
React render(JS 线程)
→ 生成/更新 ShadowNode(C++)→ Yoga 计算布局
→ commit 新的 ShadowTree(整体替换,不可变)
→ MountingCoordinator 生成 mount items
→ UI 线程应用指令:create / update / remove 原生视图
→ 绘制上屏
代码或图示
ShadowTree(v1) ──commit──▶ ShadowTree(v2)
│
mount items(结构化指令)
▼
原生视图树(UI 线程)
常见误区
- 以为 Fabric 是"新的 JS 框架":React 编程模型不变,变的是渲染实现。
- 以为每次状态变化都全量重建原生视图:重建的只是 shadow 树节点,原生视图按指令差异更新。
追问
- 不可变 shadow 树的好处是什么?答:一次 commit 是一个完整快照,布局与挂载基于同一份数据,避免跨线程读到半更新状态。
- 挂载为什么必须在 UI 线程?答:原生视图只能在平台 UI 线程创建与修改,跨线程直接操作视图是未定义行为。
07.2.2.1-009 Codegen 的工作机制与产物是什么?
一句话结论
Codegen 在构建期读取 TS 写的模块/组件规范,生成 C++ 与平台侧的绑定代码和类型声明,让 JS 与原生的契约在编译阶段对齐,替代手写桥接胶水。
概念解释
规范通常放在 Native*.ts 文件里:模块用 TurboModuleRegistry 声明方法签名,组件用 codegenNativeComponent 声明 props 与事件。Codegen 在 package.json 的 codegenConfig 中配置(模块名、类型、源码目录、平台包名等),构建时生成到各自的生成目录。
它解决的是长期痛点:手写桥接时,JS 侧 API 与原生实现容易漂移,参数类型靠约定维持。Codegen 让"规范即契约",改动签名必须改规范,改规范必须重新生成,否则构建失败。
原理流程
TS/TSX 规范(NativeXxx.ts)
→ codegenConfig 指定扫描范围与输出参数
→ 构建期生成:C++ 绑定、Android 抽象类/委托、iOS 协议实现骨架
→ 原生实现继承/实现生成的抽象
→ JS 侧 import 生成的 Spec 类型
代码或图示
// 示意:package.json 中的 codegen 配置(字段名以版本为准)
{
"codegenConfig": {
"name": "MySpecs",
"type": "all",
"jsSrcsDir": "src/specs",
"android": { "javaPackageName": "com.example.specs" }
}
}
常见误区
- 以为 Codegen 只生成文档:它产出参与编译的代码,缺了它原生绑定不存在。
- 以为改原生实现可以不改规范:签名真相在规范里,实现必须匹配生成的抽象。
追问
- Codegen 产物要不要进版本库?答:生成目录通常不纳入版本管理,由构建任务重新生成(以项目实际约定为准)。
- 规范写错会怎样?答:构建期报错或运行时签名不匹配,属于"早失败"设计。
07.2.2.1-010 新旧架构的渲染管线有哪些本质差异?
一句话结论
旧管线是「JS diff → 跨桥 → Shadow 线程 Yoga → 跨桥 → 主线程挂载」的四段式异步链路;新管线是「JS 渲染 → C++ shadow 树 commit(含 Yoga 布局)→ 挂载指令 → UI 线程应用」,中间不再有字符串序列化与前后的线程跳跃。
概念解释
旧管线的每一次树更新都要经过两次跨边界,且布局结果要回到 JS 侧才能继续(旧架构里测量结果异步回传)。新管线把树与布局都放在 C++ 里,同一次 commit 已经包含布局结果,挂载只等 UI 线程可用。
另一个本质差异是"读一致性":旧管线里 JS 树、shadow 树、原生视图树可能处于不同版本,异步链路越长越容易出现读到旧布局的情况;新管线以不可变树 + commit 为单位,三者在每个 commit 边界上对齐。
原理流程
旧:JS diff →(桥)→ Shadow 树 → Yoga →(桥)→ UI 线程挂载 → 绘制
新:JS render → C++ ShadowTree(commit, 含 Yoga) → mount items → UI 线程挂载 → 绘制
代码或图示
| 维度 | 旧管线 | 新管线(Fabric) |
|---|---|---|
| 树的归属 | JS 侧 + shadow 树 | C++ 核心 |
| 布局线程 | Shadow 线程 | C++ 渲染阶段 |
| 跨边界次数 | 每帧 2 次以上 | 不再有字符串往返 |
| 一致性 | 各树版本可能错位 | 以 commit 为一致边界 |
| 并发渲染 | 不支持 | 支持 |
常见误区
- 认为新管线把渲染搬到原生就"零成本":挂载仍在 UI 线程,视图数量与绘制依旧是主成本。
- 认为两种管线的 JS 代码写法不同:React 写法一致,差异在能力与性能表现。
追问
- 为什么新管线能支持并发渲染?答:不可变 shadow 树 + commit 让 React 可以打断、重排而不破坏已提交的视图状态。
- 迁移后渲染问题会消失吗?答:不会。视图层级过深、图片过大、阴影/圆角/遮罩等绘制成本仍需单独优化。
07.2.2.1-011 新架构下线程模型发生了哪些变化?
一句话结论
线程的角色重新分配:React 渲染与 C++ shadow 树构建在 JS 线程完成(含 Yoga 布局),挂载在 UI 线程执行,异步任务回到各自的原生线程池;旧架构中专门承担布局的 Shadow 线程不再作为独立一环存在。
概念解释
旧架构的三段式线程让布局独立于 JS 与 UI,代价是两次跨线程。新架构把布局并入 C++ 渲染阶段:JS 线程上 React 渲染出新的 shadow 树并计算布局,UI 线程只做挂载与绘制。线程数变少了,但单个 commit 在 JS 线程上的工作量变大——这也解释了为什么新架构下"JS 线程长任务"依然是最常见的卡顿源。
原生模块的线程语义没有变:模块方法默认在模块自己的线程调用,需要 UI 线程的操作要显式切线程,需要 JS 线程的回调也要显式调度。
原理流程
JS 线程:React render → ShadowNode 更新 → Yoga 布局 → commit
↓ 挂载指令
UI 线程:apply mount items → 原生视图创建/更新 → 绘制
↓ 事件
JS 线程:事件分发 → 业务逻辑
原生工作线程:网络/存储/解码(完成后调度回目标线程)
代码或图示
旧:JS ─(桥)─ Shadow(布局) ─(桥)─ UI
新:JS(渲染+布局) ──(mount items)── UI
常见误区
- 认为新架构把工作都搬到了原生所以 JS 不卡了:渲染与布局仍在 JS 线程,长任务照样掉帧。
- 认为原生模块回调默认在主线程:线程语义由模块实现决定,UI 更新必须自行切主线程。
追问
- 新架构下如何判断掉帧归因?答:先看 JS 线程帧内是否有超预算的 render/commit,再看 UI 线程挂载与绘制耗时,两边都可能独立超时。
- 为什么布局放在 JS 线程不是退步?答:省掉一次跨线程与跨边界往返,总延迟更低;但要求 JS 侧避免长任务。
07.2.2.1-012 Bridgeless 模式是什么,去掉了什么?
一句话结论
Bridgeless 是新架构下「不再创建 Bridge 实例」的运行模式:JS 与原生之间只通过 JSI 与 C++ 核心通信,模块调用、事件、渲染指令都不再经过旧的消息队列。
概念解释
旧架构下即使开启了新渲染与模块,只要 Bridge 还在,就仍有一份消息队列与序列化路径,也仍有一批依赖 Bridge 的旧 API。Bridgeless 把 Bridge 整个移除,改用 ReactHost / RCTHost 这类宿主对象统一管理运行时、surface 与模块。
对业务的影响主要是两类:一是依赖 NativeModules 直接取模块、依赖 Bridge 事件的旧代码需要改;二是部分旧库没有 bridgeless 适配,会在这个模式下失效或降级。
原理流程
Bridge 模式:JS 运行时 ↔ Bridge(消息队列) ↔ 原生
Bridgeless:JS 运行时 ↔ JSI ↔ C++ 核心(Fabric/TurboModules)↔ 原生
代码或图示
| 关注点 | Bridge 模式 | Bridgeless |
|---|---|---|
| 通信通道 | 消息队列 + 序列化 | JSI 直接调用 |
| 宿主对象 | Bridge 实例 | ReactHost / RCTHost |
| 旧库依赖 | 通常可用 | 需 bridgeless 适配 |
| 默认状态 | 旧版本默认 | 新架构版本逐步默认(待确认) |
常见误区
- 以为 Bridgeless 就是新架构:它是新架构的一种运行形态,架构还包含 Fabric 与 TurboModules。
- 以为 Bridgeless 下可以继续随意用 Bridge API:相关 API 会被移除或抛错,需要按迁移指南替换。
追问
- 如何判断项目是否处于 Bridgeless?答:看运行时的宿主对象与开关配置,或观察启动日志中的架构标识(具体字段以版本为准,待确认)。
- Bridgeless 对启动有什么影响?答:省去 Bridge 初始化与模块表构建,启动链路更短,但宿主与 surface 的初始化仍需优化。
07.2.2.1-013 并发渲染在 RN 中如何落地?
一句话结论
并发渲染依赖新架构:Fabric 的不可变 shadow 树让 React 可以中断、丢弃、重排渲染而不破坏已提交视图,从而支持 startTransition、Suspense 等能力;旧架构下 React 只能运行在同步的 legacy 模式。
概念解释
并发的本质是「渲染工作可被打断」。在旧架构里,一次渲染必须一次跑完并把指令送过桥,中途打断会产生不一致的视图状态;新架构把提交做成原子操作:被打断的那次渲染没有 commit,就等价于没发生。
业务上最常用的是把非紧急更新标记为 transition(列表筛选、搜索联想),让输入与滚动保持响应;Suspense 则用于把异步数据依赖与占位视图组合起来。需要注意并发不等于并行:JS 仍是单线程,被打断的工作最终还是要跑完。
原理流程
用户输入(紧急) → 同步渲染 → commit → 挂载
非紧急更新 → startTransition → 可中断的 render
├─ 有更高优先级插入 → 丢弃当前 render,重新开始
└─ 无插入 → 完成 render → commit
代码或图示
// 示意:把非紧急更新降级,保证输入响应
const [query, setQuery] = useState('');
const [list, setList] = useState<Item[]>([]);
// 输入立即更新,列表计算放入 transition(API 以版本为准)
startTransition(() => setList(filter(all, query)));
常见误区
- 以为并发会让 JS 变多线程:并发是调度策略,执行仍在 JS 单线程上。
- 以为所有更新都该进 transition:紧急更新(输入、点击反馈)必须保持同步优先级。
追问
- 并发渲染对状态管理有什么要求?答:外部 store 需通过
useSyncExternalStore之类的一致性接口接入,否则撕裂风险回归。 - 什么场景收益最大?答:大列表筛选、复杂表单联动、可中断的首屏拼装;纯计算密集任务收益有限。
07.2.2.1-014 Hermes 与新架构是什么关系?
一句话结论
Hermes 是 JS 引擎,新架构是运行时与渲染/模块体系,二者正交:Hermes 可以在旧架构下运行,新架构也可以换用别的引擎;但 Hermes 的字节码预编译与低内存特性,是新架构启动与内存收益的重要前提之一。
概念解释
Hermes 在构建期把 JS 预编译成字节码,运行时省去解析与部分编译开销,且不带 JIT,内存占用与包体特征与 JSC 不同。它与新架构的交集在 JSI:JSI 需要引擎暴露 C++ 接口,Hermes 是官方主要支持的引擎,因此新架构 + Hermes 是目前最主流的组合。
面试中常见混淆是把两者当同一件事:问「新架构迁移要不要换引擎」时,正确答案是"不必,但官方组合与最优实践通常以 Hermes 为基线"。
原理流程
构建期:JS 源码 → Hermes 编译 → 字节码(.hbc)
运行时:加载字节码 → 执行(无 JIT)
接口层:Hermes 暴露 JSI 后端 → C++ 核心调用
代码或图示
引擎(Hermes / JSC …) ←─ 正交维度 ─→ 架构(旧 Bridge / 新 Fabric+TurboModules)
交点:JSI 后端适配
常见误区
- 以为 Hermes 是新架构的一部分:它是引擎,可独立开启或关闭。
- 以为 Hermes 有 JIT 所以更快:它没有 JIT,收益来自启动与内存,不是峰值计算性能。
追问
- Hermes 下调试有什么差异?答:通过 Chrome DevTools 协议调试,能力与源码映射以工具链版本为准(待确认)。
- 关闭 Hermes 有什么理由?答:极少数依赖 JSC 特性或特定库的场景,需实测评估,不建议无依据切换。
07.2.2.1-015 新架构迁移的标准路径分哪几步?
一句话结论
四步:先升版本与依赖到支持新架构的区间,再开架构开关跑通构建,然后逐个修复 Codegen/模块/组件不兼容项,最后灰度放量并保留可回退的开关与包。
概念解释
迁移很少是"一次开关",因为不兼容点分散在:原生模块(需要 TurboModule 规范或 Interop)、原生组件(需要 Fabric 组件规范)、依赖 Bridge 的旧 API、依赖旧渲染行为的第三方库、以及自定义的启动代码。每一步都要有独立的验证手段,否则问题会混在一起无法归因。
要特别强调"可回退":开关与包都要能退回旧架构,否则一旦线上出问题就只能回滚版本,代价高得多。
原理流程
1. 版本与依赖评估:RN 版本、React 版本、核心库兼容矩阵
2. 打开架构开关:Android gradle.properties / iOS Podfile 环境变量(字段以版本为准)
3. 构建与运行:修复 Codegen 报错、模块缺失、组件渲染异常
4. 全量回归:启动、列表、动画、原生能力、崩溃率
5. 灰度放量:小流量 → 扩大 → 全量,保留开关与回退包
代码或图示
验证矩阵(示例):启动耗时 / 首屏 / 长列表帧率 / 原生模块调用 / 崩溃率 / 包体积
每项都要有旧架构基线,否则无法判断"是否变差"
常见误区
- 只在小范围功能上验证就全量:架构变更影响全局,必须全链路回归。
- 迁移时同时改业务:架构问题与业务问题混在一起,定位成本翻倍。
追问
- 迁移中最常见的第一批报错是什么?答:Codegen 找不到规范或生成失败、原生模块未实现生成的抽象、旧组件在新渲染下属性不生效。
- 灰度期间关注哪些指标?答:崩溃率、启动耗时 P90、列表帧率、原生能力调用失败率、页面白屏率。
07.2.2.1-016 第三方库不兼容新架构时如何判断与处理?
一句话结论
先按「是否含原生代码」分层判断:纯 JS 库基本不受影响;含原生模块/组件的库要看是否提供新架构适配或至少能走 Interop;既无适配又阻塞关键路径的,替换或自建封装。
概念解释
判断依据可以按三层走:一层看库的仓库与发布说明是否标注新架构支持;二层看它的原生实现是否已声明为 TurboModule/Fabric 组件(或依赖 Interop 层);三层实测——在开启新架构的构建里跑它的关键路径,观察是否有模块缺失、渲染异常、事件丢失。
处理策略有四类:升级到适配版本、用 Interop 临时兜住、在本地 fork 补适配、直接替换为社区替代方案。选择时优先考虑"是否在关键路径",非关键路径可以接受临时降级。
原理流程
依赖清单 → 标注是否含原生代码
├─ 纯 JS:低风险,验证行为差异
└─ 含原生
├─ 有官方新架构支持 → 升级
├─ 无支持但可用 Interop → 临时兜底 + 制定替换计划
└─ 完全不可用 → 替换/自研,排期评估
代码或图示
| 风险等级 | 特征 | 处置 |
|---|---|---|
| 低 | 纯 JS、无原生依赖 | 直接升级验证 |
| 中 | 有原生但走 Interop 可用 | 灰度观察,规划替换 |
| 高 | 有原生且无适配、关键路径 | 立即替换或 fork 适配 |
常见误区
- 只看 README 的一句话承诺就判定可用:必须实测关键路径。
- 把所有不兼容都留给 Interop:Interop 是过渡手段,长期留在关键路径会持续付出性能代价。
追问
- 如何快速扫出含原生代码的依赖?答:检查依赖目录是否含
android/、ios/源码或.podspec,以及是否有原生源码文件。 - 自研封装的成本点在哪?答:规范定义、双端实现、线程与数据类型转换、以及后续版本维护。
07.2.2.1-017 Interop 兼容层解决了什么,代价是什么?
一句话结论
Interop 层让旧架构的原生模块与原生组件在新架构下继续可用:它把旧模块包装成 TurboModule 形态、把旧组件包装成 Fabric 组件形态,代价是多一层转发与部分能力(如并发、同步测量)不可用。
概念解释
它的价值在于"不必为迁移一次性重写所有原生代码",让迁移可以拆成两步:先切架构跑通主链路,再逐个把关键模块升级为原生新架构实现。它的代价在于包装本身:调用路径多一层映射,参数仍可能需要转换,某些新架构特性(例如同步测量、部分事件语义)在旧组件上表现不一致。
因此正确的用法是"过渡期工具":对关键路径、高频调用、复杂组件的旧实现,应尽快改成原生新架构实现。
原理流程
旧模块(旧签名) → Interop 包装 → 生成/模拟 TurboModule 接口 → JS 调用
↓
转发到旧实现(多一层映射)
代码或图示
性能对照(定性):
原生 TurboModule < Interop 包装的旧模块 <(更差)旧 Bridge 路径
关键路径应尽量落在最左侧
常见误区
- 以为 Interop 让所有旧代码"零成本"迁移:它只是让编译与运行不失败。
- 以为 Interop 包装的组件行为与原生 Fabric 组件完全一致:部分属性/事件/测量语义存在差异。
追问
- 怎么判断某个旧组件是否值得改?答:按调用频率、是否在滚动/动画路径、是否有同步测量需求排序。
- Interop 会长期存在吗?答:属于过渡能力,长期看应随旧架构冻结而收敛(具体时间线待确认)。
07.2.2.1-018 综合题:团队反馈"升级新架构后卡顿没改善",你怎么论证与推进?
一句话结论
先拆指标再拆归因:分别量 JS 线程帧内耗时、UI 线程挂载与绘制耗时、视图数量与图片成本、以及是否仍有旧路径(Interop/旧 Bridge)在关键路径上;用"改动前后同场景对比"证明瓶颈位置,再决定是继续优化业务还是回头修架构适配。
概念解释
这类问题的陷阱是接受"新架构=性能提升"的隐含前提。新架构减少的是跨边界与序列化开销,它不会自动减少视图数量、图片解码、布局复杂度与 JS 计算量。所以论证的第一步是把"卡顿"翻译成可测的分解指标,第二步是确认新架构是否真的生效(是否有模块仍走 Interop、是否 Bridgeless、Codegen 是否正常生成)。
推进要给出可执行结论:若是 JS 长任务,优化渲染与计算;若是视图过多,做层级与列表虚拟化;若是 Interop 关键路径,排期改造;若是指标本身口径不一致(如对比了不同机型/不同场景),先统一口径再谈优劣。
原理流程
1. 明确场景与机型 → 建立旧架构基线(同包同场景)
2. 确认架构生效:是否 bridgeless、是否有 Interop 模块、Codegen 产物是否存在
3. 分线程量:JS 帧内 render/commit、UI 帧内 mount/draw
4. 分成本量:视图节点数、图片数/尺寸、布局深度、事件频率
5. 定位最大项 → 出改造方案 → 灰度验证指标 → 决定保留/回退
代码或图示
判定树(示意):
卡顿 → JS 帧内超预算? ── 是 → 优化渲染/计算/状态粒度
└─ 否 → UI 帧内 mount/draw 超预算? ── 是 → 减视图/图片/绘制特效
└─ 否 → 检查事件与同步调用、Interop 关键路径
常见误区
- 用"新架构已开启"作为结论,而不是作为前提去继续排查。
- 对比不同版本、不同机型、不同数据量下的帧率,得出无效结论。
追问
- 如果确认是 Interop 关键路径导致,怎么排优先级?答:按调用频次与是否在滚动/动画帧内排序,高频路径优先改造。
- 什么情况下应当回退架构?答:关键能力在新架构下无法满足(如某原生库必须依赖旧渲染语义)且短期无法替换时,保留开关回退,同时制定替换计划。