Node.js 事件循环深入：阶段、优先级与实战陷阱

   ┌───────────────────────────────┐
   │          timers               │  ← setTimeout / setInterval 到期回调
   ├───────────────────────────────┤
   │      pending callbacks        │  ← 部分系统操作的延迟回调（如 TCP 连接错误）
   ├───────────────────────────────┤
   │      idle, prepare            │  ← 内部使用，业务代码不感知
   ├───────────────────────────────┤
   │          poll                 │  ← 取出并执行 I/O 事件回调；可能阻塞等待
   ├───────────────────────────────┤
   │          check                │  ← setImmediate 回调
   ├───────────────────────────────┤
   │      close callbacks          │  ← close 事件（socket 关闭等）
   └───────────────────────────────┘

Promise.resolve().then(() => console.log('promise 1'));
process.nextTick(() => console.log('nextTick 1'));
process.nextTick(() => {
  console.log('nextTick 2');
  Promise.resolve().then(() => console.log('promise 2 (在 nextTick 内排队)'));
});
queueMicrotask(() => console.log('queueMicrotask'));
setTimeout(() => console.log('setTimeout'), 0);

// 输出：
// nextTick 1
// nextTick 2
// promise 1
// promise 2 (在 nextTick 内排队)      ← nextTick 清空后，轮到整个 Promise 队列
// queueMicrotask
// setTimeout                          ← 宏任务最后

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

// 输出顺序不定：取决于进入 timers 阶段时 1ms 定时器是否已到期。
// 这受进程启动时刻的时钟精度影响，是环境敏感行为。

const fs = require('node:fs');
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0);   // 下一轮 timers
  setImmediate(() => console.log('immediate'));  // 本轮 check：poll 后紧跟 check
});
// I/O 回调里永远先 immediate 后 timeout

import { monitorEventLoopDelay, IntervalHistogram } from 'node:perf_hooks';

const h = monitorEventLoopDelay({ resolution: 20 });   // 20ns 粒度
h.enable();

setInterval(() => {
  console.log({
    meanMs: (h.mean() / 1e6).toFixed(2),
    p99Ms: (h.percentile(99) / 1e6).toFixed(2),
    maxMs: (h.max / 1e6).toFixed(2),
  });
  h.reset();                                           // 周期重置，看的是滚动窗口
}, 30_000).unref();

function installBlockDetector(thresholdMs = 100): void {
  let last = performance.now();
  const timer = setInterval(() => {          // 不会被阻塞影响的是"到点后排队"，间隔能反映延迟
    const delta = performance.now() - last;
    last = performance.now();
    if (delta > thresholdMs) {
      console.warn(`event loop blocked ${delta.toFixed(0)}ms`);  // 生产环境接告警与抓栈
    }
  }, 20);
  timer.unref();
}

# CPU 火焰图：--cpu-prof 直接产出 .cpuprofile，用 DevTools/Inspector 加载分析
node --cpu-prof --cpu-prof-dir=./profiles server.mjs
# 压测期间收集，结束后在 profile 里按"Self Time"排序，前几个栈就是阻塞元凶

async function processBatched<T>(items: T[], batchSize: number, handler: (batch: T[]) => Promise<void>) {
  for (let i = 0; i < items.length; i += batchSize) {
    await handler(items.slice(i, i + batchSize));
    await new Promise<void>((resolve) => setImmediate(resolve));   // 让出：poll 有机会处理 I/O
  }
}

// worker.mjs — 跑在独立线程，有自己的事件循环
import { parentPort, workerData } from 'node:worker_threads';

const { payload } = workerData;
const result = cpuHeavyComputation(payload);   // 想跑多久跑多久，不影响主线程
parentPort.postMessage(result);

// main.mjs — 主线程发起任务
import { Worker } from 'node:worker_threads';

function runWorker<T, R>(payload: T): Promise<R> {
  return new Promise((resolve, reject) => {
    const worker = new Worker(new URL('./worker.mjs', import.meta.url), { workerData: payload });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => { if (code !== 0) reject(new Error(`worker exited ${code}`)); });
  });
}

import { pbkdf2 } from 'node:crypto';

const start = Date.now();
const jobs = Array.from({ length: 8 }, (_, i) =>
  new Promise<void>((resolve) =>
    pbkdf2(`pw-${i}`, 'salt', 100_000, 32, 'sha256', () => resolve()),
  ),
);
await Promise.all(jobs);
console.log(`8 个 pbkdf2 总耗时: ${Date.now() - start}ms`);
// 默认线程池 4：8 个任务两批执行，耗时约等于"单任务耗时 × 2"

# 提高线程池并重跑，总耗时应下降到接近单批
UV_THREADPOOL_SIZE=8 node bench.mjs