引子

你大概已经用 AI 写过不少 Node.js 代码了。

让 Copilot 帮你生成一个 Express 路由，几秒钟的事。让它写一段文件读取逻辑，async/await 包得整整齐齐。大多数时候，这些代码能跑，甚至跑得不错。

但总有一些时刻。事情开始变得诡异：

• setTimeout 和 Promise 的执行顺序，跟你在浏览器里的经验对不上。
• setImmediate 和 process.nextTick两个你在前端从没见过的 API，文档说的和实际跑出来的不一样。
• 一个看起来没问题的异步操作，在高并发下突然表现异常。

去问 AI，它会给你一个看似合理的解释。但如果追问细节——“为什么在 I/O 回调里 setImmediate 一定比 setTimeout 先执行？”——它往往含糊其辞，甚至给出错误答案。

这不怪 AI。其实，事件循环的行为比较依赖运行时上下文。同一段代码在不同位置执行，结果可能完全不同。这不是靠模式匹配能答对的问题。

作为前端开发者，你对“异步”并不陌生。 你知道 Promiseasync/await知道“不要阻塞主线程”。其实，但这些认知建立在浏览器的事件循环模型上——而那个模型。在 Node.js 里会产生误导。

你以为懂的事件循环

在浏览器里你可能已经内化了这样一个流程：

1. 从宏任务队列取一个任务执行（比如 setTimeout)。
2. 清空所有微任务（.n,queueMicrotask)。
3. If needed,perform rendering .
4. 回到第 1 步。

This model works for most front‑end scenarios.

Pain point #1: 把这个模型直接搬到 Node.js 时你会发现很多地方对不上：

• No “rendering”.
• A six‑phase loop instead of a single macro queue.
• The microtask flush timing differs.
• The existence of setImmediate/process.nextTick.

从示例来看。浏览器 vs Node.js 输出差异隐藏在更复杂场景中

// 在浏览器控制台和 Node.js 中分别运行，对比输出顺序
console.log;setTimeout => { console.log;})，不过，Promise.resolve.n => { console.log;})，queueMicrotask => { console.log;})，console.log;

The output is identical in both environments because code only touches timers and microtasks. The real divergence appears when setImmediate,process.nextTick。and I/O callbacks coexist.

Node.js 事件循环的全貌

The loop is driven by libuv and consists of six distinct phases per tick:

┌───────────────────────────┐
│ timers │ ← setTimeout / setInterval callbacks
├───────────────────────────┤
│ pending callbacks │ ← system‑level callbacks
├───────────────────────────┤
│ idle,prepare │ ← internal use only
├───────────────────────────┤
│ poll │ ← retrieve new I/O events;execute I/O callbacks
├───────────────────────────┤
│ check │ ← execute setImmediate callbacks
├───────────────────────────┤
│ close callbacks │ ← e.g.,socket 'close' events
└───────────────────────────┘

Pain point #2: Many developers assume “if re’s work,it runs immediately”. In reality。each phase processes its own FIFO queue **only** when loop reaches that phase.

The two special queues that run **娱乐ween** phases are:

1. process.nextTick's next‑tick queue.
2. The Promise microtask queue,`queueMicrotask`).

This means microtasks are not part of any phase;y are flushed at every phase transition .

六个阶段，逐个击破

1️⃣ timers 阶段

• Description: Executes callbacks scheduled by setTimeout/`setInterval`.
• Pain point #3: The delay is a *minimum* delay. If loop is busy in anor phase。timer fires later than you expect.

// timer-precision.js
const start = Date.now;老实说，setTimeout => {
const delay = Date.now - start;console.log，},100);// 阻塞主线程 200ms
const blockUntil = start + 200;while 

If you run `node timer-precision.js`<\/cоde>。you’ll see ~200 ms actual delay because synchronous block prevented loop from reaching timers phase on time.

2️⃣ pending callbacks 阶段

This phase runs system‑level callbacks that were deferred to next loop iteration .

3️⃣ idle,prepare 阶段

An internal stage used by libuv; it never surfaces in user code.

4️⃣ poll 阶段

• Main job: Calculate how long to block waiting for I/O and n execute any I/O callbacks that are ready.

If poll queue is empty and re are no immediate callbacks pending,Node will block here until new I/O arrives or a timer expires.

// poll-demo.js
const fs = require;console.log，fs.readFile => {
console.log');// Inside I/O callback – setImmediate runs before setTimeout
setImmediate => {
console.log;})，setTimeout => {
console.log;},)，});其实，console.log;

The output demonstrates that inside an I/O callback ``setImmediate`<\/cоde>` always precedes ``setTimeout`<\/cоde>` because `setImmediate` belongs to **check** phase which follows **poll**,while `setTimeout` must wait for next **timers** phase.

5️⃣ check 阶段

• Purpose: Execute all ``setImmediate`<\/cоde>` callbacks.

A classic interview question—*which runs first?*—is answered by knowing where your code lives:

// order-main.js — 在主模块中执行
setTimeout => { console.log;},)，setImmediate => { console.log;})，

If you run this multiple times,sometimes `setTimeout` wins,sometimes `setImmediate`. The reason: after initial script finishes。event loop starts its first tick. If 1 ms timer has already expired,**timers** runs first;orwise it skips to **check** where `setImmediate` lives.

// order-io.js — 在 I/O 回调中执行
const fs = require;fs.readFile => {
setTimeout => { console.log;},)，setImmediate => { console.log;})，});怎么说呢，

No matter how many times you run it,result is always:

setImmediatesetTimeout

6️⃣ close callbacks 阶段

• This final stage handles close events such as ``socket.on`.<\/сode>.

至于微任务。不属于任何阶段的“插队者”

• `process.nextTick`<\/сode>: highest priority queue .
• `Promise.n`,`queueMicrotask`<\/сode>: standard microtask queue.

The flush order at every phase transition is: **first** clear `process.nextTick`,**n** clear Promise microtasks.

// microtask-order.js
console.log;process.nextTick => { console.log;})，Promise.resolve.n => { console.log;})，setTimeout => { console.log;},)，setImmediate => { console.log;})，console.log;

: script start : script end : process.nextTick : Promise.n : setTimeout : setImmediate

微任务穿插示例

<сodе class=​"hljs language-javascript">// microtask-娱乐ween-phases.js
const fs = require;fs.readFile => {
// We're in poll now
setTimeout => {
console.log;process.nextTick => {
console.log;})，},);setImmediate => {
console.log;process.nextTick => {
console.log;})，});process.nextTick => {
console.log;})，怎么说呢，Promise.resolve.n => {
console.log;})，});

: nextTick : Promise.n : setImmediatesetNext tick inside se tIm mediate : s etT im eout : n extTi ck i nside s etTi meou t

⚠️ process.nextTick 的危险面

<сodе class=​"hljs language-javascript">// starvation.js — 不要在生产环境运行！function recursiveNextTick {
process.nextTick => {
console.log;recursiveNextTick;// 永远不会让出控制权
});}
recursiveNextTick;setTimeout => {
console.log;},)，

。

---