Node.js 内存泄漏诊断实战

内存曲线   ↘ 平稳 → ↗ 线性爬升 → 触顶 OOM
现象       RSS 只增不减，GC 越来越频繁，CPU 升高
后果       k8s/PM2 反复重启，慢请求与 5xx 增多

1. GC 压力大 → 事件循环停顿 → 请求变慢
2. RSS 撑爆 → OOM Kill → 服务重启 → 用户掉线
3. 内存碎片 → 触顶提前 → 雪崩

新生代（年轻）   → 分配快、GC 频繁（Scavenger）
老生代（久驻）   → 晋升后存活期长，GC 稀少但耗时长
大对象区         → 超过某尺寸直接进老生代

node --expose-gc -e "
  global.gc();
  const used = process.memoryUsage();
  console.log({ heapUsed: used.heapUsed, external: used.external });
"

import { writeHeapSnapshot } from 'node:v8';

// 定时或触发式生成快照
const snapshotPath = writeHeapSnapshot();
console.log(`快照已生成：${snapshotPath}`);

node --compare-heapsnapshot heapA.heapsnapshot heapB.heapsnapshot

对象数量 增长  → 什么对象越积越多
保留大小 增长  → 什么对象占据最多内存

1. 抓快照 A（服务刚启动，基线）
2. 压测/跑真实流量一段时间
3. 抓快照 B
4. 对比：找数量与 Retained Size 都增长的构造函数
5. 沿 Retaining Path 找到持有者，修复引用

const cache = new Map();

function trackUser(id) {
  const heavy = loadBigProfile(id);   // 大对象
  cache.set(id, () => {
    return heavy.name;                // 闭包一直引用 heavy，永不释放
  });
}

const memo = new Map();

function memoize(key, fn) {
  if (!memo.has(key)) memo.set(key, fn());
  return memo.get(key);
}

function handleOrder(order) {
  eventBus.on('payment', () => processPayment(order));   // 泄漏：监听器越积越多
}

eventBus.once('payment', () => processPayment(order));   // 一次性监听
// 或不再需要时 eventBus.off('payment', handler)

setInterval(() => {
  const data = getData();
  buffer.push(data);   // buffer 无上限，定时器一直跑
}, 1000);

node --trace-gc app.js

Scavenge 2167.6 -> 2168.7 MB, 1.8 ms
Mark-sweep 2199.1 -> 2211.3 MB, 82.4 ms

1. Mark-sweep 后堆大小每次都比上次大 → 泄漏在增长
2. GC 频率越来越密、单次时间越来越长 → 堆压力大
3. Scavenge 次数激增 → 短命对象分配过多

node --trace-gc --trace-gc-ignore-scavenger app.js > gc.log 2>&1
# 只看老生代 GC，过滤噪音

// 伪代码：提取 Mark-sweep 后的堆大小，画趋势
const lines = fs.readFileSync('gc.log', 'utf8').split('\n');
for (const line of lines) {
  const m = line.match(/Mark-sweep (\d+\.\d+) -> (\d+\.\d+) MB/);
  if (m) console.log(m[1], m[2]);   // 观察 after 值是否单调上升
}

node --inspect app.js

Heap snapshot    → 抓快照，看构造函数与 Retained Size
Allocation      → 记录分配，看函数级别的内存增长
Sampling       → 采样分析，开销低适合线上

Array (buffer)
  └─ closure (setInterval 回调)
       └─ global

node --heapsnapshot-signal=SIGUSR2 app.js
# kill -USR2 <pid>  触发堆快照落盘

// 接近内存上限时，主动 dump 并退出让守护拉起
const MAX_HEAP = 400 * 1024 * 1024;
setInterval(() => {
  if (process.memoryUsage().heapUsed > MAX_HEAP) {
    writeHeapSnapshot('/tmp/leak-dump.heapsnapshot');
    process.exit(1);   // PM2/k8s 自动重启
  }
}, 30 * 1000);

// 压测场景：跑 1 万次典型操作，对比 GC 后堆大小
test('内存无泄漏', async () => {
  global.gc();
  const before = process.memoryUsage().heapUsed;
  for (let i = 0; i < 10000; i++) await handleOrder(order(i));
  global.gc();
  const after = process.memoryUsage().heapUsed;
  expect(after - before).toBeLessThan(5 * 1024 * 1024);
});