Node.js 事件循环：单线程模型下的并发魔法

Node.js 凭借其高效的并发处理能力，在后端开发领域占据重要地位。而这一切的核心，正是事件循环（Event Loop） 。作为 Node.js 实现非阻塞 I/O 操作的关键机制，事件循环让单线程的 JavaScript 能够高效处理大量并发任务。本文将从原理到实践，深入解析 Node.js 事件循环的工作机制。

一、为什么需要事件循环？

JavaScript 是单线程的 ------ 同一时间只能执行一段代码。这一特性简化了代码逻辑（无需处理多线程同步问题），但也带来了挑战：如果遇到耗时操作（如文件读取、网络请求），单线程会被阻塞，导致后续任务无法执行。

为解决这一问题，Node.js 引入了事件循环 ，其核心思想是：将耗时的 I/O 操作卸载给系统内核，主线程继续处理其他任务，当 I/O 操作完成后，通过事件通知主线程执行回调。

简单来说，事件循环的作用是：协调回调函数的执行顺序，实现非阻塞 I/O，让单线程的 Node.js 能够高效处理并发。

二、事件循环的工作原理

事件循环由 Node.js 底层的 libuv 库实现，其运行过程可以理解为一个不断循环的 "阶段检查" 流程。每个阶段都有一个任务队列（FIFO），事件循环会按顺序执行每个阶段的任务，直到队列清空或达到回调限制，再进入下一个阶段。

事件循环的六个阶段

事件循环按照固定顺序依次执行以下六个阶段，每个阶段都有明确的职责：

scss 复制代码

   ┌───────────────────────────┐
┌─>│           timers          │ 阶段1：执行 setTimeout()/setInterval() 的回调
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │ 阶段2：执行延迟到下一轮循环的 I/O 回调（如某些系统操作的回调）
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │ 阶段3：仅内部使用（idle 用于闲置处理，prepare 用于准备下一阶段）
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │ 阶段4：处理 I/O 回调（如文件读取、网络请求）
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │ 阶段5：执行 setImmediate() 的回调
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │ 阶段6：执行关闭回调（如 socket.on('close', ...)）
   └───────────────────────────┘

1. timers（定时器阶段）

职责：执行 setTimeout() 和 setInterval() 调度的回调函数。
细节：该阶段会检查是否有到期的定时器（延迟时间已到），并按顺序执行其回调。注意：定时器的延迟时间是 "最小延迟" 而非 "精确延迟"，因为事件循环可能在处理其他阶段的任务时被阻塞。

示例：

javascript 复制代码

setTimeout(() => {
  console.log('定时器回调');
}, 100); // 最快 100ms 后执行，但可能延迟

2. pending callbacks（延迟回调阶段）

职责：执行上一轮循环中被延迟的 I/O 回调（主要是系统级操作的回调，如 TCP 错误处理）。
场景：例如，当一个 TCP 连接接收 ECONNREFUSED 错误时，某些操作系统会延迟报告错误，这类回调会在该阶段执行。

3. idle, prepare（闲置与准备阶段）

职责：仅 Node.js 内部使用，开发者无需关注。
作用：idle 阶段用于处理内部闲置任务，prepare 阶段用于为下一个阶段（poll）做准备。

4. poll（轮询阶段）

职责：处理 I/O 回调（如文件读取、网络请求的结果），并阻塞等待新的 I/O 事件。
工作流程：
1. 执行 poll 队列中的回调（按顺序，直到队列清空或达到系统限制）。
2. 如果队列清空：
  - 若有 setImmediate() 回调，进入 check 阶段。
  - 若无 setImmediate()，则阻塞等待新的 I/O 事件（如新的网络请求），一旦有事件到达，立即执行其回调。
示例（文件读取的 I/O 回调在此阶段执行）：

javascript 复制代码

const fs = require('fs');
fs.readFile('test.txt', (err, data) => { // 此回调在 poll 阶段执行
  console.log('文件读取完成');
});

5. check（检查阶段）

职责：执行 setImmediate() 调度的回调。
特性：setImmediate() 设计用于在 poll 阶段完成后立即执行，通常比 setTimeout(fn, 0) 更快（但需看执行时机）。

示例： javascript

javascript 复制代码

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

6. close callbacks（关闭回调阶段）

职责：执行关闭相关的回调。
场景：例如 socket.on('close', ...) 或 http.server.on('close', ...) 等回调在此阶段执行。

示例：

ini 复制代码

const net = require('net');
const server = net.createServer();
server.on('close', () => { // 此回调在 close callbacks 阶段执行
  console.log('服务器关闭');
});
server.close();

三、微任务与宏任务：事件循环中的优先级

在事件循环的每个阶段执行完毕后，会先清空微任务队列，再进入下一个阶段。这意味着微任务的优先级高于下一阶段的宏任务。

微任务（Microtasks）

定义：需要在当前阶段完成后立即执行的小型任务。
类型：
- Promise.then()、Promise.catch()、Promise.finally()
- process.nextTick()（Node 特有，优先级高于其他微任务）
- queueMicrotask()
执行时机：每个事件循环阶段结束后，在进入下一阶段前执行。

宏任务（Macrotasks）

定义：事件循环各阶段处理的任务（如定时器回调、I/O 回调等）。
类型：
- setTimeout()、setInterval()
- setImmediate()
- I/O 回调（如 fs.readFile、http 请求）
- 关闭回调（如 socket.on('close', ...)）
执行时机：按事件循环的阶段顺序执行。

执行顺序示例

javascript 复制代码

console.log('同步代码开始');

// 宏任务：timers 阶段
setTimeout(() => {
  console.log('setTimeout 回调');
}, 0);

// 宏任务：check 阶段
setImmediate(() => {
  console.log('setImmediate 回调');
});

// 微任务：Promise.then
Promise.resolve().then(() => {
  console.log('Promise.then 微任务');
});

// 微任务：process.nextTick（优先级更高）
process.nextTick(() => {
  console.log('process.nextTick 微任务');
});

console.log('同步代码结束');

执行结果：

arduino 复制代码

同步代码开始
同步代码结束
process.nextTick 微任务  // 微任务，优先级最高
Promise.then 微任务      // 微任务，次高
setTimeout 回调          // 宏任务，timers 阶段
setImmediate 回调        // 宏任务，check 阶段

解析：

先执行所有同步代码。
同步代码执行完毕后，清空微任务队列（process.nextTick 优先于 Promise.then）。
进入事件循环阶段，依次执行宏任务（timers 阶段的 setTimeout 先于 check 阶段的 setImmediate）。

四、常见问题与误解

1. `setTimeout(fn, 0)` 与 `setImmediate()` 的区别？

两者都用于异步执行回调，但优先级受事件循环当前阶段影响：
- 如果在 I/O 回调中调用，setImmediate() 总是比 setTimeout(fn, 0) 先执行（因为 I/O 回调在 poll 阶段，之后直接进入 check 阶段）。
- 如果在主模块中调用，顺序不确定（取决于进入事件循环的时间）。
示例（I/O 回调中）：

javascript 复制代码

const fs = require('fs');
fs.readFile('test.txt', () => {
  setTimeout(() => console.log('timeout'), 0);
  setImmediate(() => console.log('immediate'));
});
// 结果：总是先输出 'immediate'，再输出 'timeout'

2. `process.nextTick()` 属于事件循环吗？

不属于。process.nextTick() 有自己的队列，在每个事件循环阶段结束后、微任务队列执行前优先清空，甚至会阻塞事件循环（不建议嵌套调用）。

3. 事件循环会被 CPU 密集型任务阻塞吗？

会。因为 JavaScript 主线程同时只能执行一个任务，若有 CPU 密集型任务（如大量计算），会阻塞事件循环，导致定时器、I/O 回调延迟执行。

解决方案：
- 将 CPU 密集型任务拆分到 worker_threads（多线程）。
- 用 setImmediate() 分段执行，给事件循环喘息机会。

五、总结

事件循环是 Node.js 实现非阻塞 I/O 的核心机制，其本质是一个按固定阶段循环执行任务的流程：

六个阶段按顺序执行，每个阶段处理特定类型的回调。
微任务（尤其是 process.nextTick()）在每个阶段结束后优先执行。
理解事件循环的执行顺序，是编写高效 Node.js 代码的基础。

对于开发者而言，掌握事件循环有助于：

避免因回调顺序错误导致的 BUG。
优化异步代码性能（如合理使用 setImmediate() 与 setTimeout()）。
解决 CPU 密集型任务阻塞问题。

事件循环让单线程的 Node.js 拥有了处理高并发的能力，这正是它的 "魔法" 所在。

Node.js 事件循环：单线程模型下的并发魔法

一、为什么需要事件循环？

二、事件循环的工作原理

事件循环的六个阶段

1. timers（定时器阶段）

2. pending callbacks（延迟回调阶段）

3. idle, prepare（闲置与准备阶段）

4. poll（轮询阶段）

5. check（检查阶段）

6. close callbacks（关闭回调阶段）

三、微任务与宏任务：事件循环中的优先级

微任务（Microtasks）

宏任务（Macrotasks）

执行顺序示例

四、常见问题与误解

1. setTimeout(fn, 0) 与 setImmediate() 的区别？

2. process.nextTick() 属于事件循环吗？

3. 事件循环会被 CPU 密集型任务阻塞吗？

五、总结

1. `setTimeout(fn, 0)` 与 `setImmediate()` 的区别？

2. `process.nextTick()` 属于事件循环吗？