跳到主要内容

Node 的 Event Loop：阶段、微任务、process.nextTick、setImmediate 怎么讲？

面试速答（30 秒版 TL;DR）​

  • Node 的事件循环不是浏览器那套“渲染驱动模型”，它没有浏览器渲染阶段，核心是 libuv 驱动的多阶段循环。
  • 面试最稳的答法是：Node 每一轮会按 phase 处理不同来源的回调，常见重点是 timers、poll、check；同时每个阶段切换点还会清空高优先级任务。
  • 在 Node 里要分清 3 类东西：process.nextTick、Promise 微任务、普通 phase 回调。优先级通常是 process.nextTick > Promise 微任务 > 当前轮后续 phase。
  • setTimeout(fn, 0) 不等于立刻执行；setImmediate(fn) 也不是微任务。两者都要等事件循环调度，只是所处阶段不同。
  • 面试不要把浏览器事件循环直接套到 Node 上。浏览器重点是 task -> microtask -> render，Node 重点是 phase + 微任务优先级 + I/O 之后的调度差异。

心智模型：Node 不是“一个队列”，而是一圈一圈跑多个阶段​

很多人会把事件循环理解成“有个回调队列，空了就拿一个执行”。这在入门时够用，但回答 Node 面试题会显得过浅。

更准确的模型是：

  1. JS 同步代码先在调用栈执行。
  2. 定时器、I/O、关闭事件等异步任务，由 Node 底层能力和 libuv 管理。
  3. 当调用栈空了，事件循环按既定 phase 去看“这一轮哪些回调可以执行”。
  4. 在阶段之间，Node 还会优先处理 process.nextTick 和 Promise 微任务。

一句话记忆：

  • phase 决定“哪类回调现在能跑”。
  • 微任务决定“当前回调跑完后，谁要立刻插队”。

一轮事件循环可以怎么画​

先记阶段顺序：timers -> pending callbacks -> idle, prepare -> poll -> check -> close callbacks。

面试说明时要补两句：

  • idle, prepare 属于内部阶段，业务开发几乎不会直接使用，知道有这层即可。
  • 高频考点不是死背 6 个名词，而是知道 setTimeout 看 timers，I/O 看 poll，setImmediate 看 check。

Node 里真正高频的是“phase + 微任务”​

1. process.nextTick​

它是 Node 自己维护的一条高优先级队列，不属于标准 Promise 微任务，也不属于某个 phase。

面试口径：

  • 当前同步代码或当前回调一结束，Node 会优先清空 nextTick 队列。
  • 因为优先级太高，如果你不断递归塞 process.nextTick，会把事件循环“饿住”。
process.nextTick(() => console.log('nextTick'))
Promise.resolve().then(() => console.log('promise'))
setTimeout(() => console.log('timeout'), 0)

console.log('sync')

常见输出：

sync
nextTick
promise
timeout

原因：

  • sync 先执行。
  • 当前同步代码结束后，Node 先清 nextTick。
  • 再清 Promise 微任务。
  • 最后才进入后续 phase 处理定时器等回调。

2. Promise 微任务​

Promise 的 then/catch/finally、queueMicrotask 属于微任务。

在 Node 里它们同样优先于后续 phase，但通常排在 process.nextTick 之后。

3. phase 回调​

这类才是你常说的“事件循环里的回调”：

  • setTimeout / setInterval
  • I/O 回调
  • setImmediate
  • close 相关回调

setTimeout 和 setImmediate 到底怎么区分​

这是 Node 面试常见追问。

先背结论：

  • setTimeout(fn, 0) 属于 timers 阶段。
  • setImmediate(fn) 属于 check 阶段。
  • 它们谁先执行，不能脱离上下文死背。

场景一：顶层直接注册​

setTimeout(() => console.log('timeout'), 0)
setImmediate(() => console.log('immediate'))

这种写法下，先后顺序不应该答死。

更稳的说法是：

  • 它们分属不同阶段。
  • 在没有额外上下文约束时，观察顺序可能受当前运行环境和时机影响。
  • 面试里不要把它讲成“永远谁先谁后”。

场景二：放在 I/O 回调里​

const fs = require('node:fs')

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

这个场景下，常见口径是 setImmediate 更容易先执行，因为 I/O 回调发生在 poll 附近，之后事件循环继续往 check 走，会先处理 setImmediate。

面试安全答法：

  • 如果题目和 I/O 回调绑定，优先想到 poll -> check，所以通常先看到 setImmediate。
  • 如果题目只是顶层注册，不要强行背固定顺序。

为什么 process.nextTick 会“饿死”事件循环​

function loop() {
  process.nextTick(loop)
}

loop()

这段代码不会形成传统意义上的同步 while (true)，但效果一样危险。

原因是：

  • 每次当前回调结束后，Node 都要先清空 nextTick 队列；
  • 而你又在清空过程中不断塞新的 nextTick；
  • 结果后面的 phase 永远拿不到执行机会。

这也是为什么面试里常说：

  • process.nextTick 适合做“马上补一个异步边界”；
  • 但不适合当成普通调度工具无限递归使用。

最小示例：把优先级一次看清​

const fs = require('node:fs')

console.log('1')

setTimeout(() => console.log('2 timeout'), 0)

setImmediate(() => console.log('3 immediate'))

Promise.resolve().then(() => console.log('4 promise'))

process.nextTick(() => console.log('5 nextTick'))

fs.readFile(__filename, () => {
  console.log('6 io')
})

console.log('7')

可以这样解释：

  • 先同步输出 1、7。
  • 同步代码结束，先跑 nextTick，再跑 Promise 微任务。
  • 然后事件循环再看当前轮哪些 phase 可执行。
  • I/O 回调要等底层读文件完成后，进入合适阶段再执行。

你在面试里不一定要把所有输出顺序背到字面级，但一定要把“为什么会这样排”讲清楚。

典型题 & 标准答法​

Q1：Node 的事件循环和浏览器有什么本质区别？​

  • 浏览器重点是任务、微任务和渲染时机。
  • Node 没有渲染阶段，重点是 libuv 的多个 phase。
  • 两边都有微任务，但 Node 额外有 process.nextTick 这个高优先级队列。

Q2：process.nextTick 和 Promise 微任务谁更早？​

  • 常见口径下，process.nextTick 更早。
  • 因为 Node 会先清 nextTick 队列，再清 Promise 微任务队列。

Q3：setImmediate 和 setTimeout(fn, 0) 谁先执行？​

  • 不能脱离上下文绝对化。
  • 在 I/O 回调里，通常更容易先看到 setImmediate。
  • 在顶层直接注册时，不建议答成“永远固定顺序”。

Q4：为什么说不要滥用 process.nextTick？​

  • 因为它优先级太高。
  • 如果持续递归加入 nextTick，后续 phase 和 I/O 都会被饿住。

易错点 / 坑​

  • 把 Node 事件循环直接画成浏览器那种“宏任务 -> 微任务 -> 渲染”。
  • 说 setImmediate 是微任务。它不是，它在 check 阶段。
  • 说 setTimeout(fn, 0) 会立刻执行。它只是“最早可被调度”，不是立即入栈。
  • 死背 setImmediate 和 setTimeout 的固定顺序，而不看是否处于 I/O 场景。
  • 忘记 process.nextTick 会比 Promise 微任务更早。

速记要点（可背诵）​

  • Node 事件循环重点不是渲染，而是 phase。
  • 高频 phase：timers、poll、check。
  • process.nextTick 优先级通常高于 Promise 微任务。
  • setTimeout 看 timers，setImmediate 看 check。
  • I/O 场景下，setImmediate 常常比 setTimeout(0) 更早观察到。
  • 不同 Node 版本在边界行为上可能有细节差异，面试里优先讲稳定原理，不要死背所有输出顺序。