Node.js 中的异步执行顺序与事件循环全解

在探讨 JavaScript 异步执行顺序时,很多技术文章常常把“浏览器的事件循环(HTML5 Event Loop)”与“Node.js 的事件循环(libuv Event Loop)”混作一谈,用简单的“宏任务执行完清空微任务”一笔带过。

但一旦遇到如下问题,很多开发者就会陷入困惑:

  • 为什么 setTimeout(fn, 0) 和 setImmediate(fn) 在脚本直接运行时的输出顺序随机不可预测,而在 I/O 回调里 setImmediate 却永远 100% 先执行?
  • process.nextTick 到底属于宏任务还是微任务?为什么它比 Promise.then 还能优先“插队”?
  • Node.js 11 前后,事件循环的执行机制究竟发生了什么天翻地覆的根本性变革?

本文将跳出简单的宏微任务表象,深入 Node.js 与底层 libuv 核心架构,彻底讲透异步任务的真实流转轨迹与执行时序。


一、架构底座:Node.js 事件循环的六大执行阶段

与浏览器中单个宏任务队列的模型不同,Node.js 底层由 libuv 驱动,其事件循环是一个严密的环形状态机,被划分为 6 个明确的执行阶段(Phases)。

事件循环启动后,会严格按照以下顺序依次轮转:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   ┌──────────────────────────────────────────┐
┌─►│ 1. timers 阶段 │ ◄── 执行 setTimeout / setInterval 到期的回调
│ └────────────────────┬─────────────────────┘
│ ┌────────────────────▼─────────────────────┐
│ │ 2. pending callbacks 阶段 │ ◄── 执行某些系统操作(如 TCP 错误)的回调
│ └────────────────────┬─────────────────────┘
│ ┌────────────────────▼─────────────────────┐
│ │ 3. idle, prepare 阶段 │ ◄── 仅供 Node.js 底层内部使用
│ └────────────────────┬─────────────────────┘
│ ┌────────────────────▼─────────────────────┐
│ │ 4. poll 阶段 │ ◄── 获取新的 I/O 事件,执行绝大多数 I/O 回调
│ └────────────────────┬─────────────────────┘
│ ┌────────────────────▼─────────────────────┐
│ │ 5. check 阶段 │ ◄── 专门执行 setImmediate 的回调
│ └────────────────────┬─────────────────────┘
│ ┌────────────────────▼─────────────────────┐
│ │ 6. close callbacks 阶段 │ ◄── 执行关闭事件的回调 (如 socket.on('close'))
└──┴──────────────────────────────────────────┘

核心阶段关键职责:

  1. timers 阶段:检查并执行已到达最小延迟时限的 setTimeout() 和 setInterval() 的回调;
  2. poll(轮询)阶段:事件循环的核心枢纽。计算本次循环应该阻塞等待的时间,处理网络数据到达、磁盘读取完成等在途 I/O 事件;
  3. check 阶段:专门供 setImmediate() 使用。当 poll 阶段空闲下来时,事件循环会顺次进入 check 阶段执行 immediate 回调。

二、微任务特权通道:process.nextTick vs Promise

在 Node.js 中,微任务根本不在 libuv 的 6 大阶段队列中! 它们由 V8 引擎直接维护,并在 JavaScript 调用栈(Call Stack)清空时由运行时强行“插队”拦截。

微任务队列内部存在严格的双层特权优先级:

1
2
3
4
5
6
7
8
9
10
11
[JavaScript 调用栈清空]
│
▼
┌──────────────────────────────────────────────┐
│ 1. nextTickQueue (特权微任务) │ ◄── process.nextTick 回调 (绝对最高优先级!)
└─────────────────────┬────────────────────────┘
│ (全部消费完毕后)
▼
┌──────────────────────────────────────────────┐
│ 2. otherMicrotaskQueue (普通微任务) │ ◄── Promise.then / catch / finally、queueMicrotask
└──────────────────────────────────────────────┘

1. process.nextTick 的绝对优先权

当主线程同步代码或某个异步回调执行完毕时,Node.js 会首先无条件清空 nextTickQueue 中的所有回调,只有当 nextTickQueue 彻底为空时,才会去执行 Promise.then 注册的微任务!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Promise.resolve().then(() => {
console.log('3. Promise then (普通微任务)');
});

process.nextTick(() => {
console.log('1. nextTick (特权微任务)');
process.nextTick(() => {
console.log('2. 嵌套 nextTick 依然先于 Promise 执行');
});
});

console.log('0. 同步代码');

// 实际输出顺序:
// 0. 同步代码
// 1. nextTick (特权微任务)
// 2. 嵌套 nextTick 依然先于 Promise 执行
// 3. Promise then (普通微任务)

⚠️ 生产死锁警示:process.nextTick 饿死陷阱(Starvation) 递归调用 process.nextTick 会导致微任务队列永远无法清空,事件循环将永远无法推进到 libuv 的任何一个阶段,所有的文件 I/O、网络请求和定时器将全部挂死被活活“饿死”!


三、划时代变革:Node.js 11+ 对事件循环的重大重构

这是 Node.js 历史上最重要的一次规范对齐改造:

  • Node.js 10 及更早版本: libuv 会把当前阶段的所有宏任务一口气全部执行完,才在阶段切换的间隙去清空微任务队列。例如如果有两个同时到期的 setTimeout,老版本会把这两个定时器都输出完,才执行其内部的 Promise。这导致老版 Node.js 的执行顺序与浏览器完全相反!
  • Node.js 11 及现代版本(与浏览器规范大一统):为了抹平与 W3C/WHATWG 规范的差异,Node.js 做出重大改进:每执行完一个单独的宏任务(如一个 setTimeout 回调),就必须立刻清空当前的所有微任务队列! 随后才去执行下一个宏任务。

因此,在今天现代的 Node.js 环境中,宏微任务的交替消费规则已与浏览器完全对齐。


四、经典谜题:setTimeout 与 setImmediate 的终极对决

场景一:直接在顶层脚本执行——顺序居然是“随机不可预测”的?

1
2
3
4
5
6
7
setTimeout(() => {
console.log('setTimeout');
}, 0);

setImmediate(() => {
console.log('setImmediate');
});

如果你反复在命令行中执行上述代码,会神奇地发现:输出顺序忽上忽下,有时候 setTimeout 在前,有时候 setImmediate 在前!

为什么会这样?

  1. setTimeout(fn, 0) 在规范和底层实现中,0 会被强制修正为最小精度 1ms;
  2. 当进程启动进入事件循环前,主线程可能耗时 0.2ms,此时第一次进入 timers 阶段,检查当前经过时间是否已满 1ms:
    • 如果 CPU 稍慢或调度延迟,耗时超过了 1ms,timers 阶段发现定时器已到期,先输出 setTimeout;
    • 如果 CPU 极快,耗时只有 0.3ms 没到 1ms,timers 阶段发现无到期定时器直接跳过,顺次流转到 check 阶段,先输出 setImmediate!

场景二:在 I/O 回调内部执行——顺序永远 100% 确定!

1
2
3
4
5
6
7
8
9
10
11
const fs = require('fs');

fs.readFile(__filename, () => {
setTimeout(() => {
console.log('setTimeout');
}, 0);

setImmediate(() => {
console.log('setImmediate');
});
});

无论在任何机器上执行多少次,setImmediate 永远 100% 先于 setTimeout 输出!

为什么在 I/O 中绝对固定?

  1. fs.readFile 的回调是在 poll(轮询)阶段 被执行的;
  2. 回调执行时,同时注册了 timer 和 immediate;
  3. 当前回调执行完毕,事件循环按顺时针向前推进:poll 阶段的下一个阶段正是 check 阶段!
  4. 因此事件循环毫不犹豫地直接进入 check 阶段执行 setImmediate。而 setTimeout 必须等待事件循环走完接下来的 close 阶段,重新绕一圈回到下一个循环的 timers 阶段才会被触发。

五、综合大实战:多层嵌套时空推演

我们通过一段结合了 Promise、setTimeout、nextTick 与嵌套宏任务的经典面试试炼代码,进行全流程推演:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
let timeout = cb => setTimeout(cb, 0);

let f = flag =>
new Promise(resolve => {
console.log('start', flag);
resolve(flag);
})
.then(flag => {
console.log('p-' + flag);
setTimeout(function __inner__() {
console.log('inner ' + flag);
}, 0);
})
.then(() => {
console.log('p-debug ' + flag);
});

timeout(function __hello__() {
console.log('hello');
f(3);
});

timeout(function __world__() {
console.log('world');
});

f(1);
f(2);

全流程推导图解

阶段 1:全局同步代码执行

  1. 注册宏任务 __hello__ ──> Timers Queue: [__hello__]
  2. 注册宏任务 __world__ ──> Timers Queue: [__hello__, __world__]
  3. 执行 f(1):
    • 同步输出:start 1;
    • 注册微任务 then1.1 ──> Microtask Queue: [then1.1]
  4. 执行 f(2):
    • 同步输出:start 2;
    • 注册微任务 then2.1 ──> Microtask Queue: [then1.1, then2.1]

阶段 2:消费同步阶段产生的微任务

此时 JavaScript 调用栈空闲,立即排空微任务:

  1. 执行 then1.1:
    • 同步输出:p-1;
    • 注册宏任务 __inner__ 1 ──> Timers Queue: [__hello__, __world__, __inner__ 1];
    • 注册其链式后置微任务 then1.2 ──> Microtask Queue: [then2.1, then1.2];
  2. 执行 then2.1:
    • 同步输出:p-2;
    • 注册宏任务 __inner__ 2 ──> Timers Queue: [..., __inner__ 2];
    • 注册链式微任务 then2.2 ──> Microtask Queue: [then1.2, then2.2];
  3. 执行 then1.2 ──> 输出:p-debug 1;
  4. 执行 then2.2 ──> 输出:p-debug 2。

至此,微任务队列全部清空!

阶段 3:进入事件循环,执行 Timers 宏任务

事件循环开始轮转,进入 Timers 阶段取第一个宏任务 __hello__:

  1. 执行 __hello__:
    • 输出:hello;
    • 调用 f(3):同步输出:start 3,产生微任务 then3.1;
  2. 【Node 11+ 关键规则】单个宏任务结束,立即清空微任务!
    • 执行 then3.1 ──> 输出:p-3;
    • 产生宏任务 __inner__ 3 与微任务 then3.2;
    • 执行 then3.2 ──> 输出:p-debug 3;
  3. 继续消费下一个定时器 __world__:
    • 输出:world;
  4. 随后按入队顺序依次消费后续定时器:
    • 输出:inner 1
    • 输出:inner 2
    • 输出:inner 3

最终控制台精准输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
start 1
start 2
p-1
p-2
p-debug 1
p-debug 2
hello
start 3
p-3
p-debug 3
world
inner 1
inner 2
inner 3

六、生产实践总结与避坑速记

在实际架构与业务开发中,牢记以下几条核心铁律:

1
2
3
4
5
[异步调度原则速记表]
1. 需要立即优先处理的微任务: 使用 process.nextTick() (但切忌死循环递归)
2. 跨平台标准微任务: 使用 Promise.resolve().then() 或 queueMicrotask()
3. 想要在当前 I/O 周期结束后立即执行: 优先使用 setImmediate() 而不是 setTimeout(fn, 0)
4. 绝不在关键异步链路中写无意义的 setTimeout(..., 0) 碰运气

彻底掌握 libuv 六大执行阶段与微任务的消费边界,不仅能让我们在复杂的异步并发代码中做到游刃有余、精准掌控时序,更能让我们在排查深水区性能瓶颈与偶发时序 Bug 时直击本质。


Node.js 中的异步执行顺序与事件循环全解
https://bubao.github.io/posts/f05aaded.html
作者
一念
发布于
2021年11月18日
许可协议