稍候片刻,月出文自明。
setTimeout(0) 和 setImmediate 的顺序;递归微任务会饿死 I/O,共享线程池也会排队。内存上,Buffer 池化和共享会影响堆外读数,判断泄漏要看 GC 后的趋势,再对比两次堆快照找持有链。AsyncLocalStorage 跟着异步资源走,跨线程、进程或 HTTP 要显式传递。工程上,留意模块缓存、原生扩展 ABI 和 Node 版本差异;部署时给堆外内存留余量,处理好 PID 1,把存活与就绪探针分开。优化先看 p95/p99 和性能剖析,再动代码。import { readFile } from 'node:fs';
setTimeout(() => console.log('1 timeout'), 0);
setImmediate(() => console.log('2 immediate'));
process.nextTick(() => console.log('3 nextTick'));
Promise.resolve().then(() => console.log('4 promise'));
readFile(new URL(import.meta.url), () => {
console.log('5 io');
process.nextTick(() => console.log('6 io nextTick'));
setImmediate(() => console.log('7 io immediate'));
setTimeout(() => console.log('8 io timeout'), 0);
});
console.log('0 sync');
// 0 sync → 3 nextTick → 4 promise → 1/2(主模块里顺序不确定)
// → 5 io → 6 io nextTick → 7 io immediate → 8 io timeoutimport { readFile } from 'node:fs/promises';
import { performance } from 'node:perf_hooks';
// 同时发起 8 个读:默认 4 线程,会分成两批
const t0 = performance.now();
await Promise.all(
Array.from({ length: 8 }, (_, i) => readFile(`./data/${i}.json`, 'utf8'))
);
console.log((performance.now() - t0).toFixed(0) + 'ms');
// 用 UV_THREADPOOL_SIZE=8 再跑一次对比const slab = Buffer.allocUnsafe(16);
slab.write('abcdefgh');
const part = slab.subarray(2, 5); // 共享同一块内存
part[0] = 'Z'.charCodeAt(0);
console.log(slab.toString()); // abZdefgh
const copied = Buffer.from(slab); // 复制:改 copied 不影响 slab
copied[0] = 0x41; // 'A'
console.log(slab[0], copied[0]); // 97 65import { StringDecoder } from 'node:string_decoder';
const decoder = new StringDecoder('utf8');
const buf = Buffer.from('中文', 'utf8'); // 6 字节
// 模拟网络分包:把字节流切成两块
console.log(decoder.write(buf.subarray(0, 4))); // 中
console.log(decoder.write(buf.subarray(4))); // 文
console.log(decoder.end()); // 空字符串import { AsyncLocalStorage } from 'node:async_hooks';
import { EventEmitter } from 'node:events';
const als = new AsyncLocalStorage();
const bus = new EventEmitter();
bus.on('job', () => console.log('listener', als.getStore()));
// 监听器注册在上下文外,执行时取的是 emit 处的上下文
als.run({ traceId: 't1' }, () => {
bus.emit('job'); // listener { traceId: 't1' }
setTimeout(() => console.log('timer', als.getStore()), 0);
}); // timer { traceId: 't1' }:定时器在 run 内创建
bus.emit('job'); // listener undefined
setTimeout(() => console.log('early', als.getStore()), 0);
// early undefined:定时器在上下文外创建,之后才触发也不会补上上下文import v8 from 'node:v8';
const s = v8.getHeapStatistics();
console.log((s.heap_size_limit / 1024 ** 3).toFixed(2) + ' GB 上限');
console.log(v8.getHeapSpaceStatistics().map(
(x) => `${x.space_name}:${(x.space_size / 1024 ** 2).toFixed(0)}MB`
));
// 运行中拍快照:文件很大,别往生产磁盘上随手拍
v8.writeHeapSnapshot('/tmp/heap.heapsnapshot');// 解析一个说明符,得到绝对 URL(20.6 起不再需要 flag)
console.log(import.meta.resolve('node:fs')); // node:fs
console.log(import.meta.resolve('./lib/a.js')); // file:///.../lib/a.js
// 在 ESM 里用 CJS 的能力
import { createRequire } from 'node:module';
const require = createRequire(import.meta.url);
const pkg = require('../package.json');// addon.c
#include <node_api.h>
static napi_value Add(napi_env env, napi_callback_info info) {
size_t argc = 2;
napi_value argv[2];
napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
double a, b;
napi_get_value_double(env, argv[0], &a);
napi_get_value_double(env, argv[1], &b);
napi_value sum;
napi_create_double(env, a + b, &sum);
return sum;
}
NAPI_MODULE_INIT() {
napi_value fn;
napi_create_function(env, "add", NAPI_AUTO_LENGTH, Add, NULL, &fn);
napi_set_named_property(env, exports, "add", fn);
return exports;
}{
"targets": [
{ "target_name": "addon", "sources": ["addon.c"] }
]
}
Node.js 高级知识点整理:运行时内部、异步上下文与工程纵深
基础篇把运行时、模块、事件循环、进程和工程化按六条线归过档,进阶篇往多核、流、内存和可靠性又走了一层。这一篇不重复那些结论,只处理「会用、但说不清为什么」的部分:一次 setTimeout 到底在哪个阶段执行、libuv 线程池什么时候变成瓶颈、Buffer 的 8 KB 池子如何影响内存读数、AsyncLocalStorage 的上下文为什么在某些回调里会丢、以及把服务放进容器之后 Node 还要注意什么。
适合读者:已经能独立写 Node 服务、读过官方 API 文档,想弄明白运行时内部行为的人。示例都能用 node 直接跑,输出写在注释里。Node 迭代很快,涉及版本和实验性功能的地方我都标了出处,具体行为以当前版本的官方文档为准;拿不准的细节别当规范用,先在本机跑一遍。
01|四个层次:先判断问题出在哪一层
同样一句「Node 慢」,可能落在四个完全不同的层次。分层不是为了背概念,是为了选对工具。
实用的判断顺序:先看事件循环延迟是否正常(不正常说明主线程被占),再看线程池有没有排队(CPU 不高但请求慢),然后看堆内堆外内存,最后看内核与容器指标。顺序反了,容易在应用层反复改代码,而问题其实在 ulimit。
进程里到底还挂着哪些句柄,可以直接问运行时:process.getActiveResourcesInfo()(17.3 起)返回当前活跃资源的类型列表,排查「进程不退」比猜快。
02|事件循环:阶段只是骨架,插队才是关键
官方文档把循环分成 timers、pending callbacks、idle/prepare、poll、check、close callbacks 六个阶段。真正决定输出顺序的是另外两件事:每个回调执行完之后清空微任务队列(先 process.nextTick 队列,再 Promise 微任务),以及 poll 阶段在没有定时器到期时会阻塞等待 I/O。
三条结论值得记住:
poll 的阻塞行为解释了一个常见困惑:没有定时器、也没有 setImmediate 时,poll 会一直等 I/O;有定时器时,它最多等到最近一个定时器到期。所以 setTimeout(fn, 0) 的实际下限是 1 ms,而且在主模块里常常被推迟到下一轮。
close 回调阶段处理 socket 关闭之类的收尾;process.on('exit') 不属于任何阶段,它是事件循环清空后的最后时机,里面只能做同步操作,异步写日志会丢。想确认自己这套版本和平台上的真实顺序,别查博客,直接跑。
03|libuv 线程池:4 个线程撑起所有「异步」文件操作
Node 的异步不等于「所有东西都非阻塞」。JS 在主线程跑,但 fs、dns.lookup、crypto 的部分接口和 zlib 都交给 libuv 的线程池。默认 4 个线程,UV_THREADPOOL_SIZE 可调(上限 1024)。
几个容易被忽略的事实:
什么时候该调大:大量并发文件读写、图片或日志压缩、批量口令哈希,同时 CPU 没满、事件循环延迟正常、只是任务在排队。调太大也有代价:线程切换、每个线程一份栈,以及把下游打得更狠。
这个对比只在「读的是不同文件、磁盘能并行」时可信;文件都在页缓存里时差别会很小。测量永远是第一步。
04|Buffer:一个池子、两种拷贝、三处共享
Buffer 是 Uint8Array 的子类(Node 4 起),所以它既有 TypedArray 的接口,又指向一块 V8 堆之外的内存。理解三点就够了:池化、共享、外部内存。
slab 带来两个现象:小 Buffer 会互相「拴住」——只要还有一个 1 KB 的 Buffer 活着,整块 8 KB 都不能回收;process.memoryUsage().external 里看到的可能比你预期多。这也是「rss 涨了但 heapUsed 没涨」的常见原因之一。
共享是零拷贝的代价:subarray、slice、Buffer.from(arrayBuffer) 都不复制,改一个另一个也变;Buffer.from(buffer) 才真正复制。
文本边界是另一个高频 bug:流里对每个 chunk 直接 toString(),可能切断多字节字符(中文、emoji),表现为偶发乱码或替换符。string_decoder 会把不完整的字节留到下一块,是正确做法。
还有两个细节:Buffer.byteLength(str) 是字节数,str.length 是 UTF-16 码元数,限制请求体大小时必须用前者;单个 Buffer 的上限看 buffer.constants.MAX_LENGTH,超过会抛 RangeError,超大文件只能流式处理。
05|异步上下文:AsyncLocalStorage 的传播规则
async_hooks 暴露的是异步资源的生命周期(init / before / after / destroy / promiseResolve),每个资源有 asyncId 和 triggerAsyncId。直接拿它做链路追踪可行,但每个异步资源都要记账,开销明显,日常应该用封装好的 AsyncLocalStorage。
ALS 的关键不是「存了值」,而是「上下文跟着异步资源走」:run(store, fn) 执行时,fn 里创建的所有异步资源都记住了这个 store,它们的回调再触发时 store 会被恢复。由此有三条推论:
几个配套 API 的用途:enterWith(store) 影响当前同步执行流的后续部分,容易「泄漏」到不该有上下文的代码;snapshot()(19.8 起)返回一个函数,能在任意时刻恢复当时的上下文,适合把回调交给不支持 async hooks 的代码;AsyncResource.bind(fn) 把函数绑定到当前上下文,用于补齐丢失的场景。
性能上要有预期:ALS 建立在 async hooks 之上,每个异步资源都有额外开销。给每条日志挂上下文通常没问题,但在每秒几十万次的高频路径上要先测;更轻的替代是显式传 ctx,或只用 diagnostics_channel 做事件埋点(它不带上下文,只做低开销广播)。
06|GC 与堆快照:先分清「涨」和「漏」
V8 的堆分代。新生代(semi-space)用 Scavenge 复制存活对象,快而频繁;对象熬过一次以上回收就会晋升到老生代,老生代用标记-清除 / 标记-整理,配合增量标记与并发标记,慢但次数少。
堆上限用 v8.getHeapStatistics().heap_size_limit 读,--max-old-space-size 改;--max-semi-space-size 影响新生代大小,调大能减少晋升,但单次 Scavenge 的内存占用也会上升。容器里要给堆外内存留位置(Buffer、native、栈、代码段),上限取容器限制的七成上下是个起点,具体看压测。
判断泄漏的正确流程是「等 GC 之后看趋势」,不是看瞬时值。--expose-gc 下可以手动调 global.gc()(只用于排查,生产别开);更稳的是 --heapsnapshot-signal=SIGUSR2 在运行时按需落盘,或 --heapsnapshot-near-heap-limit 接近上限时自动拍。拿两次不同时间的快照,在 DevTools 的 Memory 面板做 Comparison,按 Delta 排序,再用 Retainers 找到持有链。
三种常见误判:rss 不下降不等于泄漏——V8 不一定会立刻把空闲页还给系统,操作系统也可能保留;Buffer 在 external 里,堆快照看不到它;监听器、定时器、闭包引用在快照里往往通过 context 链持有,只看构造函数不够,必须看 retainers。
07|模块加载器:从 require.cache 到 loader hooks
CJS 与 ESM 的差别在加载器这一层才看得清。CJS 是运行时同步求值:包装函数执行完,exports 就是结果;模块实例缓存在 require.cache 里,键是解析后的绝对路径。删除缓存可以重新加载,但已经持有旧引用的模块不会更新——热重载工具必须处理这个「旧引用」问题,光删 cache 是不够的。
ESM 是三段式:解析(resolve)→ 链接(link,建立所有 import 绑定)→ 求值(evaluate)。链接在求值之前完成,所以循环依赖不会给出「半个对象」,但访问未初始化的绑定会抛 ReferenceError(TDZ)。ESM 的缓存是模块映射,键是 URL——带不同 query、或者 file:// 与裸路径,都可能被当成不同模块加载两次。
需要改变加载行为时(TS 转译、路径别名、mock、虚拟模块),Node 提供 customization hooks:module.register()(20.6 起)把 hooks 跑在独立线程里,适合重活;更新的 module.registerHooks() 是同步 hook,跑在当前线程,写法简单但会阻塞主线程。两者都还是相对新的能力,API 细节随版本调整。
一个实际限制:require(esm) 从 Node 22.12 起默认可用,但含顶层 await 的 ESM 不能被 require,会抛 ERR_REQUIRE_ASYNC_MODULE。库作者要么避免在入口用顶层 await,要么同时提供 CJS 入口。
JSON 在两种系统里也不同:CJS 的 require 直接读 JSON;ESM 需要导入属性 with { type: 'json' },并且拿到的是默认导出。少了属性是直接报错,不是警告。
08|原生扩展:Node-API 是唯一稳定的 ABI
原生扩展(.node 文件)本质是动态库,require 时由 process.dlopen 加载。直接写 V8 的 C++ API 能拿到全部能力,但 ABI 随 V8 版本变化,Node 大版本一升级就得重编译;Node-API(旧称 N-API)是一层 C 接口,ABI 稳定,编译一次能在多个 Node 大版本上跑。
什么时候值得写:CPU 密集且 worker 也解决不了、需要复用已有的 C/C++ 库、需要直接操作系统能力。什么时候不值得:一次性计算(worker 足够)、只是想让代码「快一点」(先 profile)、团队没有 C++ 维护能力(预编译二进制、多平台 CI 都是成本)。
几个必须知道的边界:addon 在每个 worker 线程里会被加载一次,模块级静态变量在多个 isolate 之间不共享,别拿它当跨线程状态;从 C++ 回调 JS 要用 napi_threadsafe_function 或 napi_async_work,不能从任意线程直接调 JS;发布时用 prebuildify / prebuild-install 提供预编译二进制,别让用户在安装时现场编译——alpine 这类没有工具链的镜像会直接装不上。
还有一条更省事的路:计算逻辑能用 C/C++ 写出但不需要系统调用时,先考虑编译成 WebAssembly 放进 worker。它没有 ABI 问题,也不需要为每个平台出二进制,代价是能力受限、需要处理内存边界。
09|性能:怎么测,怎么读火焰图
优化前先确定指标:延迟看 p95 / p99 而不是平均,吞吐看单位时间完成量,同时盯事件循环延迟和 CPU。平均值会把长尾抹平,而长尾决定用户体验。
基准测试的四条纪律:
CPU profile 的读法:node --cpu-prof app.js 产出 .cpuprofile,拖进 Chrome DevTools 的 Performance 面板。先用「自顶向下」找到总耗时最长的调用链,再切「自底向上」看谁是自己耗时最多的叶子。注意区分 JS 帧和 (program) / native 帧:大量时间落在 (program) 里,通常意味着 I/O 等待、GC 或者 C++ 层,不在你的 JS 代码里——这时候继续优化 JS 是白费力气。
没有图形界面时用 node --prof app.js,再用 node --prof-process isolate-*.log 得到按 tick 统计的摘要;它比火焰图粗,但足够判断「时间花在哪个函数上」。第三方工具(0x、clinic 系列)把火焰图和事件循环延迟放在同一张时间轴上,定位「哪段代码导致循环卡住」更直接。
优化的顺序几乎总是:换算法或数据结构 → 减少分配与序列化 → 加缓存 → 并行或下沉到 native。反过来做(先上 native)通常只是把一个 10 倍的浪费搬到了更贵的地方。
10|自带的工程工具:不必什么都装
Node 近几个版本把不少「以前要装包」的能力收进了运行时,用之前先确认版本:
权限模型(--permission,20 起以实验性身份出现)可以限制文件读写、子进程、worker、addon 的范围,是「万一被打了也只能碰到这些路径」的兜底。它不能替代容器隔离与最小权限用户,而且 flag 名称和稳定状态在版本间有调整,用之前查当前文档。
单文件可执行(SEA)把脚本和 Node 二进制打成一个文件:--experimental-sea-config 生成 blob,复制一份 node 可执行文件,用 postject 注入 blob,再做代码签名。它适合小工具和 CLI,不适合带原生依赖或运行时动态 require 的服务;体积也会增加几十 MB——里面装的就是一整个 Node。
11|部署:把 Node 放进容器之后
容器里有三件事和本机不一样:
存活与就绪要分开:liveness 只判断进程是否卡死,readiness 判断能不能接流量。把数据库、缓存的健康检查塞进 liveness,下游一抖就会触发容器批量重启,反而把故障放大。
只读文件系统、非 root 用户、固定的 NODE_ENV,是最省事的三条默认值。启动快照(--build-snapshot / --snapshot-blob)能缩短冷启动,但它对模块副作用敏感,属于「先量收益再上」的优化。
12|一张自查表
下面这些是「知道 API、但用错了层次」时最常见的形状,出问题先按表过一遍:
13|收个尾:四条线
高级内容和进阶的区别不在 API 多少,而在「能不能解释行为」。这一篇的四条线是:调度(阶段、微任务、线程池)、内存(slab、external、分代回收)、上下文(异步资源与 ALS 的传播边界)、边界(加载器、native、容器)。遇到说不清的现象,先定位它在哪一层,再决定用什么工具取证。
下一步的建议很具体:挑一个慢接口用 --cpu-prof 读一遍;把一次内存上涨用两次快照对比一遍;把 ALS 用在日志上,观察哪些回调丢了 traceId。做完这三件事,这篇里的多数结论就不再是别人的经验。