一段读配置的代码长这样:

async function loadConfig() {
  return JSON.parse(await fs.readFile(path, 'utf8'));
}

const config = loadConfig();
console.log(config.timeout);

运行后打印 undefined,再访问一层就报 Cannot read properties of undefined。原因是 loadConfig() 调用时忘了写 await,config 拿到的是一个 Promise 对象,不是解析后的配置。我实测打印 typeof r 是 object,r instanceof Promise 是 true。

更让人困惑的是输出顺序。同样几行代码,nextTick、Promise.then、setTimeout(0)、setImmediate 打印出来的先后,和写在代码里的顺序完全不一样。这些不是随机的,而是事件循环的固定规则。这篇把规则拆开,并用本机实测的顺序贴出来。Node v24.21.0,Windows x64。

事件循环在调度什么

事件循环(event loop)是 Node 里负责「从队列里取回调并执行」的调度器。JavaScript 本身在调用栈上同步执行,遇到异步操作(定时器、I/O、网络)就登记一个回调,等操作完成,回调被放进对应的队列,事件循环在合适的时机取出来执行。

Node 的事件循环分六个阶段,按顺序循环:定时器(timers)、待处理回调(pending callbacks)、空闲与准备(idle/prepare)、轮询(poll)、检查(check)、关闭回调(close callbacks)。每个阶段有自己的队列,执行完一个阶段再进下一个。

Node 事件循环的阶段顺序
timers执行到期的 setTimeout / setInterval
pending处理上一轮延迟的系统回调
poll等 I/O,执行 I/O 回调
check执行 setImmediate 回调
close执行 close 事件的回调

关键细节是:每个阶段结束、进入下一个阶段之前,Node 会清空「微任务」队列。微任务(microtask)是当前同步代码执行完后立刻要处理的小任务,Promise 的 then 回调、await 之后的代码、queueMicrotask 注册的函数都属于微任务。另外还有一条优先级更高的 process.nextTick 队列,它比 Promise 微任务还先处理。

所以「异步」不是「同时执行」,而是「先登记、后执行」。一个回调什么时候执行,取决于它被放进哪个队列、事件循环当前走到哪个阶段。理解这一点,输出顺序就不再神秘。

调用栈是「当前正在执行的函数」的堆栈。事件循环只有在调用栈空了才会取下一个回调。一个函数里写死循环,调用栈永远不空,队列里的回调再急也执行不了。所谓「Node 是单线程」,准确说是「JavaScript 执行是单线程」,libuv 的线程池和操作系统仍在并行工作,只是它们的完成通知要回到这个线程处理。

poll 阶段的职责是「等 I/O 并执行回调」。如果这时没有到期定时器、没有 I/O 事件,它会阻塞等待,直到有事件或到达下一个定时器时间。这也是为什么一个空闲的 Node 进程 CPU 接近 0,而不是空转。

事件循环不是 Node 独有的,浏览器也有类似机制,但阶段划分不同。浏览器更强调渲染帧,Node 更强调 I/O 和定时器。把浏览器里的「宏任务/微任务」结论直接套到 Node,顺序经常对不上,尤其是 setImmediate 在浏览器里根本不存在。

事件循环本身不是 JavaScript 语言的一部分,而是宿主环境提供的。Node 的循环由 libuv 实现,libuv 是一个跨平台的异步 I/O 库,负责把不同操作系统的网络、文件、定时器能力包成统一接口。理解这一点有用:文件读写、DNS 查询这类操作,libuv 会交给内部的线程池执行,完成后把回调送回主线程;网络 I/O 则更多依赖操作系统的多路复用机制。所以「单线程」指的是执行 JavaScript 的那条线程,不是整个进程只有一个线程。

「宏任务」和「微任务」是描述队列层级的两个词。宏任务指定时器、I/O 回调这类由事件循环阶段调度的任务;微任务指 Promise 回调、queueMicrotask 这类必须在当前任务结束后立刻清空的任务。可以简化成一句:两个宏任务之间,隔着一次完整的微任务清空。Node 还多一条 nextTick 队列,它排在所有微任务之前。

这两个 API 的名字有点反直觉:process.nextTick 比 setImmediate 更早执行,但名字里一个说「下一轮」,一个说「立即」。按实际顺序记更可靠:nextTick 是「当前任务之后、任何 I/O 之前」,setImmediate 是「本轮 poll 之后、下一轮 timers 之前」。名字不可靠,行为可靠。

一次实测:完整的输出顺序

我写了一个脚本,同时注册 nextTick、两个 Promise、一个 await、一个被 catch 的 rejection、两个 0 毫秒定时器、两个 setImmediate,以及一个文件读取回调。实际输出是:

sync start
sync loop 200ms done
async before await
nextTick
microtask 1
queueMicrotask
async after await
caught rejection
microtask 2
timeout 0
inner nextTick
inner microtask
outer timeout
immediate
inner immediate
io callback
io immediate
io timeout 0
timeout 10

逐段看。sync start 和 sync loop 200ms done 是同步代码,先跑完;中间那个 200 毫秒的空循环把整个线程占住了,后面所有异步回调都得等它结束。这也是为什么同步计算会拖慢所有请求。

同步代码结束后,先清 nextTick 队列,再清 Promise 微任务队列。async before await 是异步函数体里 await 之前的部分,它其实是同步执行的,所以排在 nextTick 前面。之后 async after await 作为微任务排在已经入队的 microtask 1 和 queueMicrotask 之后。

微任务清空后进入定时器阶段,timeout 0 先执行,它内部又注册了 nextTick 和 Promise,这些微任务在进入下一个阶段前被清掉,所以 inner nextTick、inner microtask 紧跟着打印。然后才是同一批里的 outer timeout,再进入 check 阶段执行 immediate 和 inner immediate。

文件读取回调属于 poll 阶段,它在本轮循环里来得晚,所以在 immediate 之后。它内部同时注册了 0 毫秒定时器和 setImmediate,结果 io immediate 先于 io timeout 0。这不是偶然:每轮循环里 check 阶段在 poll 之后、下一轮 timers 之前,所以在 I/O 回调里注册的 setImmediate 会先执行。

为什么 async before await 排在同步代码之后、nextTick 之前?因为异步函数被调用时,函数体开始执行,await 之前的部分是同步的。示例里这个异步函数在同步代码末尾调用,所以它的前半段排在 sync loop 之后;await 把后半段变成微任务,排在 nextTick 队列之后。

caught rejection 和 microtask 2 也是微任务。被 catch 的 rejection 不会变成未处理错误,它只是在微任务队列里多一个回调。顺序取决于注册顺序:先注册的 then 先执行。所以读顺序时,先看「谁先入队」,再看「在哪个阶段」。

顺带说清 await 的等价写法。await x 大致等于 Promise.resolve(x).then(后续代码),所以 await 之后的代码一定是异步执行的,哪怕 x 是一个普通数字。这解释了一个常见疑惑:await 1 之后打印的内容,为什么排在同步代码后面。它不是「等 1」,而是「把后面的代码放进微任务队列」。

nextTick 与 Promise:优先级与饿死

process.nextTick 的优先级高于 Promise 微任务。它设计上是「当前操作做完立刻执行」,不是「下个时间片」。如果在 nextTick 回调里再注册一个 nextTick,事件循环会一直清这个队列,永远进不到下一个阶段。

我写了一个递归 nextTick,让它跑 300 毫秒,同时注册一个 100 毫秒的定时器。结果:nextTick spins 2927331,定时器在 302 ms 才触发。定时器早就到期了,但事件循环没机会走到 timers 阶段。这就是「饿死 I/O」:不是 I/O 慢,是调度器被占住了。

nextTick spins 2927331
timeout fired after 302 ms

Promise 微任务也有类似风险,只是优先级稍低。递归 Promise.resolve().then(...) 同样会让阶段推进不了,只是每一轮还会给 nextTick 一点机会。实践规则很简单:不要在 nextTick 或微任务里写「无限递归」或「大批量同步循环」,要分批就交给 setImmediate。

为什么需要 nextTick?它常用于「当前操作完成后、任何 I/O 之前」做收尾,比如触发事件、清理状态。它比 setImmediate 更早,比同步代码更晚。用的时候记住它是「插队」,不是「排队」,插队插多了,别人就永远轮不到。

还有一点容易忽略:nextTick 队列和微任务队列不只在「同步代码结束」时清空,而是在每个阶段切换之间都会清空。也就是说,一个 I/O 回调里注册的 nextTick,会在进入下一个阶段前执行,不用等整轮循环结束。这也是它比 setImmediate 更「急」的原因。

定时器为什么不精确

setTimeout(fn, 0) 不是「立刻执行」。它表示「至少 0 毫秒后,在 timers 阶段执行」,实际会被最小延迟和当前阶段影响。更重要的是,定时器回调也要排队:前面有同步代码或微任务没处理完,它就得等。

我实测一个 10 毫秒的 setInterval,在有一段 200 毫秒同步循环的情况下,10 次触发的最大偏差是 292 ms,总耗时 449 ms。偏差不是定时器本身不准,而是回调被前面的同步代码挡住了。定时器只负责「到期后把回调放进队列」,不负责「准时执行」。

还有累积误差。setInterval 按固定间隔登记,如果每次回调都晚一点,误差会累加。需要稳定节奏时,用 setTimeout 在每次回调结束时重新计算下一次的时间,或者用单调时钟(process.hrtime.bigint())记录起点,按「绝对时间点」调度,而不是按「间隔」累加。

定时器的精度还受操作系统调度影响。几十毫秒级的定时器在空闲机器上比较准,机器负载高时会明显漂移。不要把定时器当实时系统的时钟用;需要严格周期的地方,得用专门的调度机制。

还有时钟精度。Date.now() 受系统时间调整影响,手动改时区或校时会让差值跳变;process.hrtime.bigint() 是单调时钟,只往前走,适合量耗时。测「这段代码跑了多久」用单调时钟,测「现在几点」才用 Date。

定时器还有几个实用细节。setTimeout 返回一个 Timeout 对象,可以用 clearTimeout 取消;调用 timeout.unref() 表示「这个定时器不阻止进程退出」,适合心跳、清理这类后台任务,反过来 ref() 恢复阻止。另外,浏览器和 Node 都会把嵌套过深的定时器最小延迟抬高到 4 毫秒左右,所以「0 毫秒套 0 毫秒」并不会真的零延迟。

setImmediate 到底何时执行

setImmediate 的名字容易误导,它不是「立即执行」,而是「在 check 阶段执行」。check 阶段在 poll 之后,所以它适合「I/O 回调处理完、让出一次循环再做下一件事」的场景。

在顶层代码里,setTimeout(0) 和 setImmediate 的先后不完全确定,取决于进程启动时第一个 timers 阶段是否已经过了 1 毫秒。我这次实测是 timeout 0 先、immediate 后,但换个机器或负载,顺序可能反过来。不要把这两者的顺序当成稳定契约。

在 I/O 回调里就确定了:setImmediate 先。因为 I/O 回调在 poll 阶段执行,紧接着就是 check 阶段;而 setTimeout(0) 要等到下一轮 timers。我的实测输出里 io immediate 在 io timeout 0 之前,正是这个原因。

想让「大批量任务」不堵住 I/O,用 setImmediate 分批。它会把剩余工作推到 check 阶段,中间给 poll 阶段机会处理网络和文件事件。这也是很多库实现「异步分片」的方式,比 nextTick 安全。

queueMicrotask 和 Promise.resolve().then 优先级相同,都进微任务队列,按注册顺序执行。区别在于前者不用构造 Promise,抛出的异常会走未处理错误的路径。我实测里 microtask 1 在 queueMicrotask 之前,就是因为前者先注册。想调整顺序就调注册顺序,不要指望换 API。

Promise 与取消

Promise 表示「未来会有一个结果」,状态只有三种:pending、fulfilled、rejected。它一旦 settled 就不能再改,也没有内建的 cancel()。所谓「取消一个 Promise」,实际是「让等待它的人提前得到一个拒绝,并让底层操作停下来」。

标准做法是 AbortController:把 signal 传给支持取消的 API(fetch、fs 的部分接口、定时器封装),到点调用 abort()。对于自己写的 Promise,要手动监听 signal 的 abort 事件并 reject。我实测一个 300 毫秒的延时,在 50 毫秒时 abort,catch 在 66 ms 收到 aborted,不用等 300 毫秒。

const ac = new AbortController();
const p = sleep(300);
setTimeout(() => ac.abort(), 50);
await new Promise((resolve, reject) => {
  ac.signal.addEventListener('abort', () => reject(new Error('aborted')));
  p.then(resolve);
});

并发和串行也要分清。我实测三个 50 毫秒的延时,串行 await 总共 184 ms,用 Promise.all 并发只要 61 ms。串行是「一个等一个」,并发是「一起等」。但并发不是越多越好:没有上限地 Promise.all 几百个请求,会把连接池和内存压满。

await 不会阻塞线程,它只是把后面的代码登记成微任务,让出调用栈。所以「await 一个慢操作」不会让别的请求停下;但「await 之前有同步大循环」会。判断阻塞看同步代码,不看 await。

未处理的 Promise rejection 在 Node 24 里默认会让进程退出,退出码 1,错误直接打到 stderr。我实测一个没有 catch 的 Promise.reject,后面的定时器根本没机会执行。要么给每个 Promise 加 catch,要么在顶层注册 process.on('unhandledRejection') 做兜底。

Promise.all、allSettled、race、any 的差别要分清。all 等全部成功,任一失败就整体 reject,其他结果也拿不到;allSettled 等全部结束,永远 resolve,每项带 status;race 取第一个结束的,成功失败都算;any 取第一个成功的,全失败才 reject。批量任务要「不因为一个失败丢掉全部」时用 allSettled,不要用 all。

async 函数抛异常,等价于返回一个 rejected Promise。如果调用方既没 await 也没 catch,这个拒绝就变成未处理 rejection。最常见的隐蔽写法是「发起异步任务但不等它」,比如事件回调里调用 async 函数却不管返回的 Promise。错误不会在调用点报出来,只在进程退出时留一行栈。

在循环里 await 是串行的:for (const id of ids) await load(id) 会一个一个来,十个 50 毫秒的任务就是 500 毫秒。想并发送先把 Promise 收集起来再 Promise.all,但要加并发上限,避免一次打出去几百个请求把连接池压满。

取消还多一个便利工具:AbortSignal.timeout(ms) 一行就能得到「到点自动 abort」的信号,省掉手写 setTimeout;AbortSignal.any([...]) 可以把多个取消源合成一个。它们和手写的控制器是同一套机制,只是少写几行胶水代码。

Promise 构造函数里同步抛异常有特殊行为:new Promise((resolve, reject) => { throw new Error('x'); }) 不会把异常直接抛到外面,而是自动变成 reject。

现象对照

现象真实原因第一步查什么
打印顺序和代码顺序不一致回调进了不同阶段的队列分清同步、nextTick、微任务、timers、check
await 之后的值是 Promise调用方忘了 await看 instanceof Promise,补 await
定时器明显晚于设定时间同步代码或微任务占住了线程量同步段耗时,找阻塞点
setInterval 越跑越偏误差按间隔累积改绝对时间点调度
顶层 setTimeout(0) 与 setImmediate 顺序不稳定第一个 timers 阶段的时间不确定不要依赖这两者的相对顺序
I/O 回调里 immediate 比 timer 先poll 之后就是 check,timer 要等下一轮确认回调所在阶段
递归 nextTick 后 I/O 卡住nextTick 队列一直清不完改 setImmediate 分批
进程突然退出,退出码 1未处理的 Promise rejection看 stderr 的 Error 和调用栈
取消请求后仍在等只 abort 了信号,没监听它确认 Promise 里监听了 abort
并发请求内存暴涨Promise.all 没有并发上限加队列或信号量控制并发数
async 函数调用后没反应返回的 Promise 没人等也没人 catch在调用处补 await 或 .catch
Promise.all 一个失败全失败all 就是快速失败语义要全部结果就换 allSettled
空闲进程 CPU 却很高有递归微任务或同步轮询用 perf_hooks 定位热点

边界与代价

事件循环的第一个代价是「不能用同步思维写异步代码」。一段同步循环能占住整个进程,一个没写的 await 能让返回值变成 Promise,一个没 catch 的 rejection 能让进程退出。这些错误都不会在编译期发现,只能靠运行时暴露。

第二个代价是「顺序不可依赖」。除了明确的规则(nextTick 先于微任务、check 在 poll 之后),很多相对顺序依赖机器、负载和启动时机。把业务逻辑建立在「A 一定比 B 先」的假设上,换环境就可能失效。

第三个代价是「取消要贯穿全链路」。Promise 没有内建取消,超时、用户中断、上游失败,都要把信号传到底层操作,并让每一层都响应。漏掉一层,请求就继续跑,资源不释放。这也是为什么现代 API 越来越多地接受 AbortSignal。

第四个代价是「观测需要工具」。光看代码很难知道某个回调在哪个阶段、等了多久。Node 提供 perf_hooks、async_hooks 这类工具,能看到异步资源和耗时。复杂问题不要靠猜,先用工具确认回调的时间线。

观测工具里最常用的是 perf_hooks 的 performance.now()。它返回高精度毫秒数,适合量「这段异步流程花了多久」,比 Date.now() 稳。再深一层是 async_hooks,它给每个异步资源打标记,能追踪「这个回调属于哪次请求」,但用起来复杂,一般只在排查异步上下文丢失时用。

小结

事件循环按 timers、pending、poll、check、close 循环推进,每个阶段之间清空 nextTick 和 Promise 微任务;nextTick 优先级最高,递归会饿死 I/O,实测 300 毫秒的 nextTick 让 100 毫秒定时器拖到 302 毫秒;定时器只保证「到期后入队」,不保证准时,10 毫秒间隔实测最大偏差 292 毫秒;setImmediate 在 check 阶段执行,I/O 回调里先于 0 毫秒定时器;Promise 没有内建取消,用 AbortController 贯穿全链路;未处理的 rejection 会让进程以退出码 1 结束。

当天可以自己验证的练习:

  1. 同时注册 nextTick、Promise.then、setTimeout(0)、setImmediate,打印实际顺序。
  2. 写一个递归 nextTick 跑 300 毫秒,观察 100 毫秒定时器实际何时触发。
  3. 在 fs.readFile 回调里同时注册 0 毫秒定时器和 setImmediate,对比顺序。
  4. 用 10 毫秒的 setInterval 统计 10 次触发的最大偏差。
  5. 写一个没有 catch 的 Promise.reject,观察进程退出码和 stderr。

到这里,Node.js 这组七篇就结束了。从模块、内置 API、流、网络,到多进程、多线程和事件循环,主线是同一件事:Node 用单线程加事件循环处理并发,CPU 密集就开线程或进程,I/O 密集就靠异步和背压。系统层面的 I/O 模型可以回看I/O 模型,进程与线程的基础可以回看进程和线程与调度。下一步如果回到语言本身,可以对照 Python 组的asyncio看两种运行时对异步的不同取舍。