#现象
一个数据聚合接口,输入是几万条订单记录,输出按商家分组的汇总。压测数据量到 5 万条时,服务端 CPU 单核跑满,P99 从 80ms 涨到 900ms。
火焰图看得很清楚:aggregate() 这一层占了 62% 的采样,里面没有 IO、没有正则、没有任何可疑的库函数,就是一层 for 循环加对象读写。
那问题只能出在「对象」本身。
#先做个对照实验
服务端是 Node 20(V8 11.x),我把它挪到本地,用 performance.now() 跑了 20 轮取中位数,构造最简复现:
// A:字段顺序一致
function buildA(rows) {
const acc = {};
for (const row of rows) {
const key = row.shopId;
if (!acc[key]) acc[key] = { shopId: key, count: 0, amount: 0, firstAt: null };
acc[key].count++;
acc[key].amount += row.amount;
}
return acc;
}
// B:字段顺序随数据变化
function buildB(rows) {
const acc = {};
for (const row of rows) {
const key = row.shopId;
if (!acc[key]) acc[key] = {};
if (row.firstFlag) acc[key].firstAt = row.createdAt; // 有时先有 firstAt
acc[key].count = (acc[key].count || 0) + 1;
acc[key].amount = (acc[key].amount || 0) + row.amount;
acc[key].shopId = key;
}
return acc;
}
| 版本 | 5 万条耗时 | 相对基线 |
|---|---|---|
| A(固定形状) | 21ms | 1.00x |
| B(顺序不定) | 36ms | 1.71x |
差异确实存在,而且和业务代码里那个「先判断再补字段」的写法一模一样。
#隐藏类是什么
V8 里每个对象都有一个隐藏类(hidden class / map),记录「这个对象有哪些属性、分别在哪个偏移」。访问 obj.amount 时,V8 不需要查字典,直接用隐藏类里的偏移量做一次内存寻址——这是 JavaScript 对象访问能接近 C 结构体的原因。
问题在于隐藏类是随赋值过程演进的:
const a = {}; // map: {}
a.x = 1; // map: { x }
a.y = 2; // map: { x, y }
每次新增属性都会产生一个新的 map,V8 内部维护一棵 map 树。只要两个对象以相同顺序走完相同的路径,它们就共享同一个 map,访问点的内联缓存(inline cache)就能命中,走「单态」快路径。
一旦顺序不同:
const b = {};
b.y = 2; // map: { y }
b.x = 1; // map: { y, x } ← 完全不同的分支
两个对象结构上「一样」,但对 V8 来说是两种类型。访问点从单态退化成多态,甚至超多态(megamorphic),每次都要重新判断形状——这就是那 1.7 倍的来源。
#怎么确认是这个问题
不靠猜。V8 提供了几个诊断入口,我在排查时用了三个。
一、--trace-ic 看内联缓存状态。(需要 --allow-natives-syntax 或直接用 d8)
node --trace-ic ./bench.mjs 2>&1 | grep "aggregate" | head -30
输出里的 1 MONO 表示单态,4 POLY 表示多态,>4 MEGA 就是灾难信号。我们那段代码在 B 版本下出现了大量 MEGA。
二、%HaveSameMap 直接比较两个对象的隐藏类。 这个只能在 d8 或开启了 --allow-natives-syntax 的 node 里用:
// 启动:node --allow-natives-syntax
const x = { a: 1, b: 2 };
const y = {}; y.b = 2; y.a = 1;
console.log(%HaveSameMap(x, y)); // false
开发环境跑一次,比读十篇博客都直接。
三、--trace-deopt 看优化是否被撤销。
node --trace-deopt ./bench.mjs 2>&1 | grep -i "deoptimiz" | head
如果函数在热起来之后被反复去优化,几乎一定是形状不稳定或者类型混杂导致的。
#修复:把形状固定下来
业务代码的修法很朴素——先建完整对象,后填值,而不是边判断边加字段:
// 修复前:字段是"长"出来的
const acc = {};
if (row.firstFlag) acc.firstAt = row.createdAt;
acc.count = (acc.count || 0) + 1;
// 修复后:字段在创建时就齐了
const acc = { shopId: key, count: 0, amount: 0, firstAt: null };
改完之后:
| 指标 | 修复前 | 修复后 |
|---|---|---|
| 5 万条耗时 | 36ms | 22ms |
| P99(全链路) | 900ms | 540ms |
| CPU 单核占用 | 98% | 61% |
40% 的整体提升,来自一行字段顺序。
#几个容易踩的变体
一、delete 直接打回字典模式。
const o = { a: 1, b: 2, c: 3 };
delete o.b; // 对象退化为 dictionary mode,后续所有访问都变慢
如果确实要「去掉一个字段」,用赋值 null 代替 delete:
o.b = null;
二、JSON.parse 出来的对象形状其实很稳定。 同一段 JSON 重复解析,V8 会缓存 map,性能很好。真正的风险在于解析后你又往里补字段——那就回到了上面的问题。
三、对象当 Map 用,键空间很大时很危险。 每次新增键都会扩展 map 树,几十万键之后查询会明显退化。数量级超过几千就该换 Map:
// 键数量不可控,用 Map
const index = new Map();
index.set(key, value);
四、构造函数里 this.x = ... 顺序不一致。 两个子类混在同一个数组里遍历,访问点必然是超多态。要么统一顺序,要么拆成两个数组。
五、数组元素类型混杂。 这条不算隐藏类,但同源:[1, 2, 3] 是 PACKED_SMI,[1, 2, 'x'] 变成 PACKED_ELEMENTS,遍历时会有额外开销。数据清洗在入口做,别留到热路径。
#什么时候不用管这些
说实话,90% 的业务代码不需要考虑隐藏类。V8 的优化已经足够宽容,几万次迭代的差异肉眼不可见。
值得关注的信号只有三个:
- 单函数占据显著 CPU 采样(比如火焰图里超过 20%);
- 数据量进入十万级且循环体内有大量对象读写;
--trace-ic里出现成片的MEGA。
三条同时成立,再去优化形状。否则你只是在给一台没坏的机器换零件。
#附:可直接复用的基准脚本
import { performance } from 'node:perf_hooks';
function bench(name, fn, rounds = 20) {
const samples = [];
for (let i = 0; i < rounds; i++) {
const t = performance.now();
fn();
samples.push(performance.now() - t);
}
samples.sort((a, b) => a - b);
const median = samples[Math.floor(samples.length / 2)];
console.log(`${name}: ${median.toFixed(1)}ms (min ${samples[0].toFixed(1)})`);
return median;
}
两点提醒:一定要先跑几轮预热(让 JIT 完成优化),一定要取中位数而不是平均值——GC 的偶发停顿会把平均值污染得毫无意义。