罗罗编程学习记录
本页内容 展开查看

07.2.2.3 Hermes 引擎与启动性能

所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.2 跨平台移动开发 / 07.2.2 React Native

本节要解决的问题

  • Hermes 与 JSC 在设计取舍上到底差在哪,为什么它能改善启动与内存?
  • 字节码预编译(hermesc / .hbc)是怎么把"启动时的解析编译"挪到构建期的?
  • RN 应用的启动链路分哪几段,TTI 的口径怎么定,怎么分段测量?
  • inline requires、分包、模块预加载这些手段分别解决启动链路的哪一段?
  • JS 包体积由什么构成,瘦身的常见手段与边界在哪?
  • Hermes 下调试、sourcemap 与栈还原怎么做,线上崩溃怎么还原?

版本前提:本页以 RN 0.70 起 Android 默认 Hermes、iOS 默认化时间点以发布说明为准(待确认)为基线;新架构(Fabric/TurboModules)与 Hermes 是正交关系,详见 07.2.2.1。涉及具体命令、字段、默认开关均需按项目实际版本核对。

覆盖范围

知识域 关键内容
引擎差异 Hermes 与 JSC 的设计取舍、字节码预编译、无 JIT、内存特征
启动链路 进程/原生壳、引擎初始化、JS 包加载执行、首屏渲染、TTI 口径
启动治理 inline requires、分包、模块预加载、预热、懒加载与注册的关系
包体积 JS 包构成、瘦身手段、源码映射与栈还原
调试监控 Hermes 调试能力、sourcemap、启动监控指标与治理流程

题号索引

题号区间 主题
001-004 Hermes 与 JSC 差异、字节码预编译、无 JIT、内存特征
005-007 启动链路分段、TTI 口径、首屏渲染与可交互定义
008-010 inline requires、分包、模块预加载与预热
011-013 JS 包体积构成、瘦身、源码映射与栈还原
014-016 Hermes 调试、启动监控治理、综合题:启动慢治理

07.2.2.3-001 Hermes 与 JSC 的核心差异是什么?

一句话结论

JSC(JavaScriptCore)是苹果维护的通用 JS 引擎,带 JIT,启动慢、内存高但峰值性能好;Hermes 是 Meta 为移动端定制的引擎,不带 JIT、构建期预编译字节码,启动快、内存低,代价是峰值计算性能略逊。

概念解释

两者都是 ES 引擎,都能跑 React,但设计目标不同。JSC 是 Safari 同源引擎,为桌面浏览器设计,启动时要解析源码、生成字节码、再由 JIT 编译成机器码;在手机上冷启动阶段这套流程成本高。Hermes 反过来:把"解析 + 编译"挪到构建期,产出 .hbc 字节码文件,运行时直接加载字节码,不做 JIT。

取舍非常清晰:JSC 用启动与内存换峰值性能,Hermes 用峰值性能换启动与内存。对 RN 这种"启动敏感、峰值计算有限"的场景,Hermes 的设计更贴合。

原理流程

JSC 启动:
  读 JS 源码 → 解析 → 生成字节码 → JIT 编译 → 执行
Hermes 启动:
  构建期 hermesc → .hbc 字节码
  运行时读 .hbc → 直接执行(无 JIT)

代码或图示

维度 JSC Hermes
JIT 有 无
启动时解析 需要 不需要(构建期完成)
包体 源码 bundle 字节码 .hbc
启动耗时 较高 较低
内存占用 较高 较低
峰值计算 较强 略弱

常见误区

  • 以为 Hermes 是新架构的一部分:它是独立的 JS 引擎,可在旧架构下运行。
  • 以为 Hermes 有 JIT:它刻意不做 JIT,启动与内存是主要收益。

追问

  • Hermes 下哪些场景可能比 JSC 慢?答:长时间运行的热点计算、大量数值运算,因为没有 JIT 优化。
  • 怎么确认项目用的是 Hermes?答:检查构建配置中引擎开关(字段以版本为准),或运行时打印引擎信息。

07.2.2.3-002 字节码预编译(hermesc / .hbc)是怎么工作的?

一句话结论

Metro 打包时把 JS 源码经 hermesc 编译成字节码文件(.hbc),原生壳加载时直接映射这段字节码到内存,省去运行时的词法分析、语法分析与字节码生成。

概念解释

普通 JS 引擎启动要做:源码 → AST → 字节码 → (JIT)机器码。Hermes 把前三步搬到构建期:Metro 产出 bundle 后,由 hermesc 编译器把 bundle 编译成 .hbc。运行时 Hermes 加载器直接把 .hbc 文件映射到内存,从字节码开始执行。

这里有几个工程要点:一是 .hbc 与 Hermes 引擎版本绑定,引擎升级后字节码要重新生成;二是字节码文件是二进制的,不能直接读源码,崩溃栈还原需要配套的 sourcemap;三是字节码可以 mmap,避免全量读入内存,对大 bundle 友好。

原理流程

Metro 打包:JS 源码 → 合并 bundle
  → hermesc → .hbc 字节码文件
运行时:
  原生壳打开 .hbc → mmap 到内存 → 从字节码入口开始执行

代码或图示

构建产物对比:
JSC:index.bundle(可读 JS 文本)
Hermes:index.hbc(二进制字节码)+ 同名 .map(sourcemap)

常见误区

  • 以为 .hbc 是加密或压缩:它是字节码,不是加密,引擎版本不匹配会加载失败。
  • 以为字节码能跨版本复用:Hermes 引擎版本升级后必须重新编译。

追问

  • 为什么 Hermes 不把字节码打进 APK 任意位置?答:字节码要随原生壳打包,且加载路径与引擎初始化逻辑绑定。
  • 开发模式为什么不用字节码?答:开发模式要支持热更新与快速刷新,必须用源码 bundle。

07.2.2.3-003 无 JIT 的取舍是什么?

一句话结论

无 JIT 意味着没有机器码缓存、没有热点路径优化,峰值吞吐量会下降;但换来的是没有 JIT 代码段的内存开销、没有 JIT 编译线程的启动延迟,以及更可预测的性能曲线。

概念解释

JIT 的工作原理是:引擎在运行一段时间后识别热点函数,把它们编译成机器码缓存起来,后续调用走机器码。这套机制在桌面浏览器里收益巨大,但在移动端有两个代价:JIT 代码段占用内存、JIT 编译本身要花时间且需要可执行内存(在某些平台/版本上对内存与安全策略有要求)。

Hermes 放弃 JIT 后,所有代码都在解释器上跑。对 RN 而言,业务代码主要是 UI 逻辑与状态流转,热点计算有限,放弃 JIT 的代价在大多数场景下不明显;但如果有大量数值计算、大列表数据处理,会感知到性能差异。

原理流程

JIT 引擎:
  解释执行 → 识别热点 → 编译机器码 → 走机器码
  (越跑越快,但前期慢、内存高)
Hermes:
  始终解释执行字节码
  (性能曲线平稳,前期快、内存低)

代码或图示

维度 有 JIT 无 JIT(Hermes)
启动后性能 前期慢后期快 始终平稳
内存 多 JIT 代码段 少一块
可执行内存 需要 不需要
热点计算 收益大 收益小

常见误区

  • 以为无 JIT = 引擎很慢:解释器本身也在持续优化,热点路径有内联缓存等手段。
  • 以为任何性能问题都该换 JSC:先 profile 确认瓶颈真在解释器上。

追问

  • Hermes 有哪些补偿手段?答:字节码层面的优化、内联缓存、隐藏类优化等(具体实现以版本源码为准)。
  • 为什么移动端 JIT 还要考虑可执行内存?答:移动系统对 W^X 策略、JIT 内存区域有约束,早年 iOS 上 JIT 甚至受限。

07.2.2.3-004 Hermes 的内存特征与 JSC 有什么不同?

一句话结论

Hermes 内存占用更低、峰值更可预测:没有 JIT 代码段、字节码只读映射、GC 策略偏移动端低延迟;但对象模型与 GC 行为不同,长时运行后内存增长曲线与 JSC 不一致。

概念解释

Hermes 的内存收益主要来自三块:一是没有 JIT 代码段,省下一块可执行内存;二是字节码文件可以 mmap,只读部分共享;三是 GC 面向移动场景,目标是停顿短而不是吞吐高。代价是:Hermes 的对象头、字符串、闭包表示有自己的模型,与 JSC 不通用;且因为没有 JIT,某些临时对象分配模式在解释器下成本不同。

工程上需要注意:Hermes 下内存问题的 profile 工具链与 JSC 不同,不能直接套用 Web 或 JSC 的内存分析经验。

原理流程

JSC 内存:堆对象 + JIT 代码段 + 字节码 + 解析器状态
Hermes 内存:堆对象 + mmap 的只读字节码 + GC 管理的对象

代码或图示

内存项 JSC Hermes
JIT 代码段 有 无
字节码 运行时生成 构建期产物,mmap
GC 策略 偏吞吐 偏低延迟
内存峰值 较高 较低

常见误区

  • 以为换 Hermes 内存问题就自动解决:业务侧的大图、缓存、监听器泄漏照样存在。
  • 以为 Hermes 内存占用始终更低:长时运行后 GC 行为差异会导致曲线不同。

追问

  • Hermes 的 GC 是什么策略?答:分代式 GC(具体实现与版本演进以官方文档为准,待确认)。
  • 怎么测量 Hermes 内存?答:用 Hermes 自带的 heap dump 工具或平台内存分析工具,具体命令以版本为准。

07.2.2.3-005 RN 应用的启动链路分哪几段?

一句话结论

冷启动可拆成:原生壳进程初始化 → JS 引擎初始化 → JS 包加载与执行 → React 首屏渲染 → 首屏可交互(TTI);每一段的耗时构成与优化手段完全不同。

概念解释

很多"启动慢"的讨论笼统地把所有时间加在一起,无法定位问题。正确的分段是:

  1. 原生壳初始化:进程创建、Application.onCreate、首屏 Activity/ViewController 初始化、第三方 SDK 初始化。
  2. 引擎初始化:创建 JS 运行时(Hermes/JSC)、加载字节码、建立 JSI 绑定。
  3. JS 包执行:执行入口模块、执行根组件模块、模块注册。
  4. 首屏渲染:React 渲染首屏组件树、Yoga 布局、原生视图挂载。
  5. 首屏可交互:首屏内容出现且能响应输入,即 TTI。

每一段都可能成为瓶颈:原生 SDK 串初始化、引擎与字节码加载、JS 模块同步执行过多、首屏组件树过重。

原理流程

进程创建
  → Application.onCreate / 原生壳初始化
  → 创建 JS 引擎(Hermes)
  → 加载 .hbc 字节码
  → 执行 JS 入口模块(含 require 图)
  → React render 首屏组件树
  → Yoga 布局 + 原生视图挂载
  → 首屏像素出现(FP)
  → 可交互(TTI)

代码或图示

阶段 典型耗时来源 优化方向
原生壳初始化 第三方 SDK 串初始化 异步/延迟初始化
引擎初始化 字节码加载、JSI 绑定 引擎复用、预热
JS 包执行 模块同步 require、顶层副作用 inline requires、分包
首屏渲染 组件树过重、布局深 延迟渲染、骨架屏
TTI 首屏后还有同步任务 把首屏后任务挪到空闲

常见误区

  • 把启动慢全部归因于 JS 包大:原生壳初始化可能占了一半时间。
  • 用开发包测启动:开发包带调试逻辑,不能代表线上。

追问

  • 热启动和冷启动差在哪?答:热启动进程已在、引擎已在,只做 Activity 重建;冷启动要走完整链路。
  • 为什么要区分 FP 与 TTI?答:FP 是首屏像素出现,TTI 是能交互,中间可能有数据加载与同步任务。

07.2.2.3-006 TTI 的口径怎么定,怎么测量?

一句话结论

TTI(Time to Interactive)是从用户点击图标到首屏可响应输入的时间;口径必须统一(从哪一刻开始、到哪一刻算可交互),且要在真机、发布包、用户路径下测量,不能用开发包。

概念解释

TTI 没有唯一标准,团队内部必须约定:起点通常是进程创建(或 Activity onCreate),终点是首屏关键内容出现且用户操作有响应。工程上常见的口径是:原生壳打点 + JS 侧首屏渲染完成打点 + 首次可交互打点,全程上报。

测量的陷阱是:开发包带调试器、热更新、未压缩代码,测出来的启动时间比线上慢好几倍;模拟器性能与真机不同;低端机与旗舰机差异巨大。所以 TTI 必须在真机发布包上测,且分位数(P50/P90)才有意义。

原理流程

起点:进程创建(或 Activity onCreate)
  → 分段打点:引擎初始化完成、JS 执行入口、首屏渲染完成、首次可交互
  → 上报到性能监控
终点:首屏关键交互可用

代码或图示

口径 起点 终点
进程启动 进程创建 首屏 Activity 可用
JS 引擎初始化完成 进程创建 引擎 ready
FP(首像素) 进程创建 首屏内容上屏
TTI 进程创建 首屏可交互

常见误区

  • 用开发包测 TTI:结果不可信,必须用发布包。
  • 只报平均值:平均值会被长尾掩盖,P90/P95 才反映真实体验。

追问

  • 怎么打点才准确?答:原生侧在关键节点埋点,JS 侧用性能 API,统一时间基准。
  • TTI 与用户感知为什么可能不一致?答:用户看到了内容但首屏还有同步任务阻塞交互,TTI 会晚于视觉感受。

07.2.2.3-007 启动期模块注册与懒加载的关系是什么?

一句话结论

旧架构下所有原生模块在启动期全量注册与初始化,拖慢启动;TurboModules 把模块改为首次访问时才创建(懒加载),从而把启动期模块成本转移到使用时;但懒加载不是免费的,关键路径模块仍需预热。

概念解释

旧架构的模块系统在启动时遍历所有注册模块,实例化并登记到模块表,方法 ID 在这时分配。模块数量多了,这部分时间线性增长。TurboModules 改了模型:模块注册只是登记工厂,真正的实例在 JS 首次访问时才创建(详见 07.2.2.1)。

对启动优化而言,这意味着启动期不必初始化那些"首屏用不到"的模块。但代价是首次访问某模块时会有一次初始化开销;如果首屏恰好要用到该模块,反而会变成首屏卡顿。所以策略是:非关键路径模块懒加载,关键路径模块在启动后预热(pre-warm)。

原理流程

旧:启动期遍历所有模块 → 实例化 → 登记
新:启动期只登记工厂 → JS 首次访问 → 实例化(懒加载)
     → 关键路径模块启动后主动 pre-warm,把初始化成本挪到首屏后

代码或图示

策略 适用模块 代价
懒加载 首屏用不到的模块 首次访问有初始化延迟
预热 首屏或关键路径模块 启动后占用 CPU,但用户无感
全量初始化 旧架构默认 启动慢

常见误区

  • 以为 TurboModules 自动解决启动:懒加载只是把成本转移,关键路径仍要预热。
  • 以为预热越多越好:预热过多会抢首屏 CPU,反而拖慢 TTI。

追问

  • 怎么判断哪些模块要预热?答:分析首屏路径上实际访问的模块,按访问频率与初始化成本排序。
  • 预热在哪个线程做?答:必须在不阻塞 JS 与 UI 的线程做,具体 API 以版本为准。

07.2.2.3-008 inline requires 是什么,为什么能改善启动?

一句话结论

inline requires 把模块的 require 从"顶层一次性执行"改成"用到时才执行",让首屏只加载首屏必需的模块,其余模块在首次访问时才加载执行,从而减少启动期 JS 包执行时间。

概念解释

CommonJS 模块的 require 是同步的:顶层 import foo from 'foo' 会在模块加载时立刻执行 foo 及其依赖的整个模块树。如果入口文件顶层引入了大量首屏用不到的模块(例如设置页、关于页、未使用的工具库),这些模块在启动期全部执行,占用 JS 线程时间。

inline requires 的做法是:把 import 改为在函数内部 require('foo'),这样 foo 模块只有在该函数被调用时才执行。这在 React 里对应 React.lazy + Suspense 做代码分割,或在工具函数内部按需 require。

原理流程

入口顶层 import 大量模块
  → 启动期全部执行 → 首屏慢
inline requires:
  入口只 import 首屏必需
  其他模块在用到时 require
  → 启动期执行的模块数减少

代码或图示

// 差:顶层引入,启动期就执行
import { SettingsPage } from './settings';
// 好:用到时才加载
function openSettings() {
  const { SettingsPage } = require('./settings');
}

常见误区

  • 以为 inline requires 自动分包:它只是推迟执行,不减少包体积,要配合分包才能减少加载量。
  • 在渲染路径上滥用 require:require 本身有成本,热路径上每次 require 会有额外开销。

追问

  • inline requires 与 React.lazy 关系?答:React.lazy 是组件级代码分割,inline requires 是模块级,两者配合使用。
  • 怎么发现哪些模块在启动期被无谓执行?答:用 Metro/React 的性能分析或 require 时间打点。

07.2.2.3-009 分包与模块预加载是怎么配合的?

一句话结论

分包把 JS 包切成"主包 + 次包",主包只含首屏必需代码,次包在需要时下载加载;模块预加载则是在首屏后、用户操作前主动加载次包,让用户真正进入时已经就绪。

概念解释

分包的本质是把"启动期必须执行"的代码和"后续才用"的代码分开。主包包含首屏组件、入口、核心模块;次包包含非首屏页面、非关键库。Hermes 下分包要处理 .hbc 字节码的加载与关联,不能只分 JS 文本。

预加载是策略:启动后空闲时间主动加载次包,但不执行;用户点击时再执行。这样把下载与加载成本从用户操作路径上挪走,代价是消耗流量与电量,需要按用户行为预测。

原理流程

启动:加载主包 .hbc → 首屏渲染
  → 空闲时间预加载次包 .hbc(下载但不执行)
  → 用户进入某页面 → 次包已就绪 → 执行次包 → 渲染

代码或图示

手段 解决的问题 代价
分包 启动期执行模块数 工程复杂度、加载协议
预加载 次包加载耗时 流量、电量
inline requires 顶层模块同步执行 代码写法变化

常见误区

  • 以为分包能直接减包体积:它是把加载时机后移,总代码量没变。
  • 预加载所有次包:浪费流量,要按用户行为预测。

追问

  • Hermes 下次包字节码怎么加载?答:需要引擎支持额外的字节码段加载,具体协议以版本为准。
  • 分包后版本不一致怎么办?答:主包与次包要做版本对齐,加载协议要处理回退。

07.2.2.3-010 启动预热(pre-warm)有哪些常见手段?

一句话结论

预热是把首屏后才需要的初始化工作提前到启动后空闲时间做,常见手段包括:JS 引擎预热、关键模块 pre-warm、首屏后数据预取、图片预热;目标是把成本移出用户可感知窗口。

概念解释

预热的前提是"用户首屏后大概率会用"。常见手段:引擎预热(在首屏渲染后创建引擎实例备用)、关键模块 pre-warm(主动触发 TurboModule 实例化)、数据预取(首屏渲染完成后预取次屏数据)、图片预热(预下载列表图片到缓存)。

预热的风险是:在首屏关键路径上做预热会抢 CPU,反而拖慢 TTI。所以预热必须放在首屏完成后,且要分优先级。

原理流程

进程启动 → 首屏渲染(关键路径,不做任何预热)
  → 首屏完成打点
  → 空闲时间按优先级预热:引擎备用实例、关键模块、次屏数据、图片

代码或图示

预热优先级示意:
P0:首屏后立即要用的(如次屏数据)
P1:用户高频路径(如列表图片)
P2:低频路径(如设置页模块)

常见误区

  • 在首屏前做预热:抢 CPU,拖慢 TTI。
  • 预热所有模块:初始化成本累加,得不偿失。

追问

  • 怎么判断预热有没有拖慢 TTI?答:对比预热开关前后的 TTI 分位数。
  • 引擎预热有收益吗?答:在多 Surface 或混合嵌入场景下,预热第二个引擎实例能让后续 RN 页面秒开。

07.2.2.3-011 JS 包体积由什么构成,怎么瘦身?

一句话结论

JS 包由业务代码、第三方依赖、polyfill、sourcemap 信息构成;瘦身手段包括剔除未用依赖、移除 polyfill、压缩混淆、按需引入,但要注意 Hermes 下是字节码,不是直接压缩文本。

概念解释

bundle 体积直接影响下载、字节码加载与内存。构成上:业务代码通常占小头,第三方依赖(尤其完整引入的 UI 库、工具库)占大头;polyfill 对现代 Hermes 可能已经不需要;sourcemap 不进发布包。

瘦身手敏:用 bundler 分析工具找出最大依赖;把完整库引入改为按需引入(如 lodash 按需);检查 polyfill 是否必要;移除调试代码与未使用的导出。Hermes 下还要注意字节码体积与源码体积的换算关系,不能只看源码包大小。

原理流程

bundle 分析:找出最大模块
  → 剔除未用依赖
  → 按需引入(避免 import 整个库)
  → 移除冗余 polyfill
  → 压缩混淆(发布构建)
  → hermesc → 字节码体积

代码或图示

构成 占比(典型) 优化手段
业务代码 小 死代码删除
第三方依赖 大 按需引入、替换轻量库
polyfill 中 按目标引擎版本裁剪
调试代码 小 发布构建剔除

常见误区

  • 只看源码包大小:Hermes 下要看字节码体积。
  • 盲目替换小库:要考虑维护性与稳定性。

追问

  • 怎么分析 bundle 构成?答:用 Metro 的 bundle 分析工具或可视化插件,具体以版本为准。
  • tree-shaking 在 RN 里有效吗?答:对 ESM 依赖有效,对 CommonJS 依赖有限。

07.2.2.3-012 Hermes 下的 sourcemap 与崩溃栈还原怎么做?

一句话结论

Hermes 字节码不直接对应源码,线上崩溃栈是字节码地址或混淆后的函数名;需要构建期保存 .hbc 对应的 sourcemap,线上用 sourcemap 把栈还原成源码位置。

概念解释

发布包是字节码,崩溃栈里的函数名、行号都是字节码层面的。要还原成可读源码,必须有:构建产物 .hbc、对应的 sourcemap 文件、以及版本信息(版本号、构建号)。线上崩溃上报时,把字节码栈上报,后端用对应版本的 sourcemap 还原。

工程上必须做到:每次发版都归档该版本的 .hbc 与 sourcemap,与版本号一一对应;否则线上崩溃无法还原。Hermes 还支持在构建时保留可读函数名(--emit-call-sites 等选项,具体以版本为准),便于调试。

原理流程

构建期:bundle → hermesc → .hbc + sourcemap
  → 归档:版本号 ↔ .hbc ↔ sourcemap
线上崩溃:上报字节码栈
  → 后端按版本号取 sourcemap
  → 还原成源码位置

代码或图示

归档示意:
v1.0.3+100
  ├─ index.android.hbc
  ├─ index.android.hbc.map
  ├─ index.ios.hbc
  └─ index.ios.hbc.map

常见误区

  • 不归档 sourcemap:线上崩溃无法还原。
  • 用最新版 sourcemap 还原旧版崩溃:版本对不上,还原位置错误。

追问

  • Hermes 栈与 JSC 栈格式不同吗?答:不同,还原工具链要按引擎区分。
  • 怎么确保 sourcemap 不泄漏到客户端?答:sourcemap 不上线,只在服务端保留。

07.2.2.3-013 Hermes 下怎么调试?

一句话结论

Hermes 下通过 Chrome DevTools 协议调试(Flipper 或官方 DevTools),支持断点、调用栈、作用域检查;但因为是字节码,调试体验与 JSC 有差异,且某些高级功能(如内存 profiling)工具链不同。

概念解释

Hermes 提供了自己的调试协议,支持 Chrome DevTools 连接。调试时可以在源码上打断点,引擎把字节码位置映射回源码。但 Hermes 调试器与 JSC 调试器不是同一套,Flipper 在官方体系中曾经是主力工具,近年官方调试入口有调整(具体工具链现状以官方文档为准,待确认)。

需要注意:发布包不能调试,调试只能在开发包或带调试开关的包上做;线上问题靠 sourcemap + 日志,不能靠 attach debugger。

原理流程

开发包 → Hermes 开启调试服务
  → Chrome DevTools / Flipper 连接
  → 断点、调用栈、作用域、控制台
发布包 → 无调试服务 → 靠日志与 sourcemap 还原

代码或图示

调试场景 工具
开发期断点 Chrome DevTools / 官方 RN DevTools
原生模块调试 平台原生调试器(Android Studio / Xcode)
线上崩溃 sourcemap 还原
性能分析 Hermes profiler / 平台性能工具

常见误区

  • 以为 Hermes 不能调试:可以调试,只是工具链与 JSC 不同。
  • 在发布包上 attach 调试:发布包不开放调试端口。

追问

  • Flipper 现在还是首选吗?答:官方工具链在调整,Flipper 的支持状态以最新文档为准(待确认)。
  • 怎么调试启动期 JS 代码?答:启动期代码运行早,调试器连接前可能已执行,需要打点或离线复现。

07.2.2.3-014 Hermes 下的性能分析怎么做?

一句话结论

Hermes 性能分析分两层:JS 层用 Hermes profiler 看函数耗时与调用栈,原生层用 Systrace/Perfetto 看线程与渲染;两者结合才能定位是 JS 长任务还是原生侧耗时。

概念解释

Hermes 提供采样 profiler,可以导出函数级耗时数据。但它只能看 JS 层,看不到原生模块的 C++/Java/ObjC 实现耗时。要完整定位,必须同时看:JS profiler(函数耗时)、平台 trace(线程调度、渲染、GC)。

常见分析路径:先看 JS profiler 是否有单函数长耗时;再看 trace 里 JS 线程是否被同步原生调用阻塞;最后看 UI 线程的挂载与绘制。

原理流程

复现问题 → 同时启动:
  ├─ Hermes profiler(JS 函数采样)
  └─ Systrace/Perfetto(全线程 trace)
分析:
  ├─ JS 函数长耗时 → 优化业务逻辑
  ├─ JS 线程被同步原生阻塞 → 改异步
  └─ UI 线程耗时 → 优化视图与绘制

代码或图示

工具 看什么 局限
Hermes profiler JS 函数耗时、调用栈 看不到原生实现
Systrace/Perfetto 线程调度、渲染、GC 不看 JS 函数内部
平台内存工具 内存、GC 引擎相关项有限

常见误区

  • 只看 JS profiler 就下结论:同步原生阻塞在 JS profiler 上表现为一个函数长,但根因在原生。
  • 用模拟器分析性能:模拟器性能与真机差异大。

追问

  • Hermes GC 停顿怎么观测?答:在 trace 里看 GC 事件,具体工具以版本为准。
  • 怎么定位 JS 长任务?答:profiler 里看单帧内耗时最长的函数,结合调用栈找根因。

07.2.2.3-015 启动监控的口径与治理流程是什么?

一句话结论

启动治理是一个闭环:定义指标口径 → 线上分位数监控 → 回归分析 → 定位瓶颈段 → 优化 → 验证 → 固化;不能靠一次性优化,要持续监控防止退化。

概念解释

启动指标必须在全量用户上监控,分 P50/P90/P95,因为平均值掩盖长尾。监控要有分维度:机型档位、系统版本、网络、冷/热启动、是否首装。治理流程是:每次发版看启动指标是否退化,退化时用分段打点定位是哪一段变慢,然后针对性优化。

常见的治理手段是:建立启动预算(每段耗时上限)、CI 中跑启动 benchmark、灰度发版看启动指标。

原理流程

1. 定义口径:起点、终点、分段打点
2. 全量上报:P50/P90/P95 分维度
3. 发版对比:新版本 vs 旧版本分位数
4. 退化定位:分段打点找出变慢段
5. 优化:针对该段做工作
6. 验证:灰度后再看分位数
7. 固化:启动预算 + CI 回归

代码或图示

指标 用途
P50 启动耗时 大多数用户体验
P90/P95 长尾与低端机体验
分段耗时 定位瓶颈段
分机型 低端机针对性优化

常见误区

  • 只看平均值:长尾被掩盖。
  • 一次性优化后不再监控:后续发版会退化。

追问

  • 启动预算怎么定?答:按机型档位分别定预算,低端机放宽,旗舰机收紧。
  • 怎么发现某次发版启动退化?答:CI 跑 benchmark + 灰度期看分位数曲线。

07.2.2.3-016 综合题:某 App 升级 Hermes 后启动变慢了,怎么排查?

一句话结论

先确认对比口径是否一致(开发包 vs 发布包、机型、版本),再分段量:引擎初始化、字节码加载、JS 执行、首屏渲染;重点怀疑字节码体积异常、初始化副作用、同步原生调用,而不是"Hermes 本身慢"。

概念解释

这类问题最常见的根因不是 Hermes 引擎本身,而是对比口径错误或工程配置问题。第一步是确认:用的是发布包还是开发包?机型一致吗?升级 Hermes 时是否同步升级了 RN 版本?是否重新编译了字节码?

第二步分段量:如果引擎初始化段变慢,可能是字节码文件损坏或版本不匹配;如果 JS 执行段变慢,可能是 Hermes 下某些模块行为差异(如正则、JSON 解析性能);如果首屏渲染段变慢,与 Hermes 无关,是渲染层问题。

第三步怀疑配置:是否开启了调试?是否字节码未压缩?是否有 sourcemap 被错误打进包?

原理流程

1. 对齐口径:发布包、真机、同机型、同版本
2. 分段打点量:
   ├─ 引擎初始化慢? → 检查字节码版本、文件大小
   ├─ 字节码加载慢? → 检查 .hbc 是否损坏、是否过大
   ├─ JS 执行慢? → Hermes profiler 找热点函数
   └─ 首屏渲染慢? → 与 Hermes 无关,按渲染管线查
3. 检查配置:调试开关、压缩、sourcemap
4. 对比 JSC 基线:确认是 Hermes 特有问题还是工程问题

代码或图示

判定树:
升级 Hermes 后启动慢
  → 对比口径一致?(开发包/机型/版本)
    ├─ 否 → 先对齐口径再测
    └─ 是 → 分段量
       ├─ 引擎初始化慢 → 字节码版本/文件
       ├─ JS 执行慢 → profiler 热点
       └─ 渲染慢 → 渲染层问题,与 Hermes 无关

常见误区

  • 直接换 JSC 回滚:没定位根因,回滚后仍可能复发。
  • 用开发包对比:开发包带调试,结果不可信。

追问

  • Hermes 下哪些 JS 代码可能变慢?答:复杂正则、大量 JSON、密集数值运算,因为无 JIT。
  • 怎么确认字节码是否正确生成?答:对比 .hbc 文件大小、检查构建日志、用 hermes 反汇编验证。