高枝个人博客 土木读研 · 计算机 × 土木的交叉笔记
返回列表

把事件循环画出来:一次请求在 Node.js 里经历了什么

调了那么久的事件循环,还是说不清 setImmediate 和 process.nextTick 的顺序差异。这篇从源码角度把整个流程理一遍。

面试里被问过无数次的问题:

javascript
setTimeout(() => console.log('timeout'));
setImmediate(() => console.log('immediate'));
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
console.log('sync');

输出是什么?为什么?

先给答案

text
sync
nextTick
promise
timeout      ← 与 immediate 顺序不保证
immediate

前三个是确定的,后两个在主模块里顺序不保证。这是个很多人忽略的细节。

从源码看 nextTick

Node 启动时会先读取环境变量初始化一个 process.nextTick 队列的实现。看简化后的核心逻辑:

javascript
// lib/internal/process/task_queues.js(简化)
function nextTick(callback) {
  if (tickInfo[kHasTickScheduled] === 0) {
    // 首次调用时才真正挂载 tickInfo
    queueMicrotask(() => {
      const asyncId = newAsyncId();
      emitInitNativeModule(asyncId, 'Tick', 0);
    });
  }
  tickInfo[kHasTickScheduled] = 1;
  tickInfo[kTickObject].push(callback);  // 存入 tick 队列
}

关键点:nextTick 队列比 Promise 微任务队列优先清空,并且是循环清空(新增的 tick 会在同一轮被处理)。

drainTicks 的位置

javascript
// 事件循环的核心
function runMicrotasks() {
  // ① 先清空 nextTick 队列
  if (hasTickScheduled()) {
    do {
      while (tickInfo[kTickObject].length > 0) {
        const cb = tickInfo[kTickObject].shift();
        cb();
      }
      tickInfo[kHasTickScheduled] = 0;
    } while (!queue.isEmpty());   // 循环:处理中新加入的 tick
  }

  // ② 再清空 Promise 微任务队列
  runMicrotasksFromQueue();
}

这个 do...while 就是 nextTick「能插队」的根源:如果回调里又调了 nextTick,它会在同一轮继续执行。

setTimeout 与 setImmediate 为什么不确定

javascript
// lib/internal/timers.js(简化)
function setTimeout(callback, after) {
  // after 会被 clamp 到 1ms,并且与内部列表插入位置有关
  after *= 1; // coerce to a number
  if (after < 1 || after > TIMEOUT_MAX) after = 1;
  // 关键:注册到 timersList,按到期时间排序
  return insert(timerListMap, msecsToRepr(after), new Timeout(callback, after));
}

function setImmediate(callback, after = 0) {
  // 注册到 immediatesList,check 阶段统一执行
  return new Immediate(callback, after);
}
  • setTimeout 走 timers 阶段,按剩余毫秒排序,受事件循环启动时机影响
  • setImmediate 走 check 阶段,每轮循环必然执行一次

在主模块顶层同步代码里,事件循环还没启动,setTimeout(0) 的实际到期时间是 1ms。如果这段同步代码本身耗时超过 1ms,那么 timers 阶段一到就会先执行它;如果耗时很短,check 阶段可能先到。

所以顺序真的不确定,取决于宿主环境和你机器当时的状态。

一个实用的排查姿势

线上遇到 setImmediate 没按预期执行,我会先打印时间戳:

javascript
const t0 = performance.now();
setImmediate(() => console.log('immediate', performance.now() - t0));
setTimeout(() => console.log('timeout', performance.now() - t0), 0);
// 两者差值能直观反映本轮循环走到了哪个阶段

什么时候用 nextTick

它的定位是「当前操作完成后立刻执行,且优先于任何 I/O」。典型用途是把异步结果转成同步可见的状态:

javascript
class Resource {
  constructor() {
    this.ready = false;
    // 避免构造完成后外部立即访问时读到中间态
    process.nextTick(() => { this.ready = true; });
  }
}

如果只是想在微任务里跑一段逻辑,用 queueMicrotask 或 Promise.resolve().then 更合适——它们语义更明确,也不会被无限制地插队。