事件循环

Node.js 的事件循环（Event Loop）是其非阻塞 I/O 模型的核心，它使得 Node.js 能够高效地处理大量并发连接。理解事件循环的工作原理对于编写高性能、响应迅速的应用程序至关重要。以下是关于事件循环的详细解释，包括其各个阶段和如何优化代码以充分利用这一特性。

事件循环的基本概念

事件循环是一个无限循环，Node.js 在其中检查任务队列和定时器，执行回调函数，并处理来自客户端的请求、数据库查询结果等异步操作。这个循环不会阻塞主线程，而是等待异步操作完成后再继续执行后续代码。

事件循环的六个阶段

事件循环分为多个阶段，每个阶段都有特定的任务类型。当一个阶段完成后，事件循环会进入下一个阶段，直到所有阶段都完成一遍，然后从头开始新的循环。

1. Timers 阶段：
   • 执行已到期的 setTimeout 和 setInterval 回调。
2. Pending I/O Callbacks 阶段：
   • 执行某些系统操作的回调，例如 TCP 错误或连接。
3. Idle, Prepare 阶段：
   • 内部使用，通常与开发者无关。
4. Poll 阶段：
   • 检索新 I/O 事件；执行与此相关的回调（几乎所有 I/O 回调，除了关闭回调、定时器回调和 setImmediate() 回调）。
   • 如果轮询队列为空，事件循环会根据是否有待处理的定时器来决定是否等待更多 I/O 事件或继续到下一个阶段。
5. Check 阶段：
   • 执行 setImmediate() 回调。
6. Close Callbacks 阶段：
   • 执行一些关闭回调，如 socket.on('close', ...)。

事件循环示意图

 ┌───────────────────────┐
 │        timers         │
 └───────────────────────┘
 │     pending I/O       │
 └───────────────────────┘
 │      idle, prepare    │
 └───────────────────────┘
 │        poll           │
 └───────────────────────┘
 │        check          │
 └───────────────────────┘
 │     close callbacks   │
 └───────────────────────┘

Timer 阶段

Timer 阶段是 Node.js 事件循环中的第一个阶段，主要用于处理定时器回调。这个阶段确保了 setTimeout 和 setInterval 等函数的回调能够在设定的时间后得到执行。理解 Timer 阶段的工作机制对于编写高效、准时的应用程序非常重要。

Timer 阶段的主要任务

1. 执行到期的定时器回调：这是 Timer 阶段的核心任务。Node.js 在这个阶段会检查所有已注册的定时器，并根据它们设置的时间间隔来决定是否应该触发对应的回调函数。只有当定时器的时间到了，其回调才会被执行。

2. 维护定时器队列：Node.js 内部维护了一个有序的定时器队列（timers queue），其中每个元素都包含一个时间戳和关联的回调函数。定时器队列按照预定的触发时间排序，最早到期的定时器排在最前面。

3. 处理高分辨率定时器：除了普通的定时器外，Node.js 还支持高分辨率定时器（如 setImmediate 和 process.nextTick），这些定时器具有更高的优先级，并且会在适当的时机插入到事件循环中。

Timer 阶段的行为逻辑

• 检查并执行到期定时器：每当事件循环进入 Timer 阶段时，它会首先检查是否有任何定时器已经到期。如果有，则立即执行相应的回调函数。注意，即使有多个定时器同时到期，Node.js 也会逐一执行它们的回调，而不是并发执行。

• 处理延迟问题：如果当前事件循环周期中有大量其他任务（例如 I/O 操作或脚本执行），可能会导致定时器的实际触发时间比预期稍晚。这是因为 Node.js 是单线程的，必须等待当前任务完成才能继续处理下一个阶段的任务。这种现象被称为“回调延迟”或“定时器滑动”。

• 最小化空闲等待：为了提高效率，Node.js 会尽量减少不必要的空闲等待。如果在 Poll 阶段没有找到新的 I/O 事件，而下一个最近的定时器即将到期，那么事件循环不会长时间阻塞，而是尽快前进到 Timer 阶段以执行到期的定时器回调。

示例代码展示 Timer 阶段行为

下面的例子展示了如何使用不同的定时器机制，并观察它们在事件循环中的行为：

console.log("Start");

// 定义一个短时间的定时器
setTimeout(() => {
  console.log("Short setTimeout");
}, 0);

// 定义一个长时间的定时器
setTimeout(() => {
  console.log("Long setTimeout");
}, 5000);

// 使用 setImmediate 创建一个高分辨率定时器
setImmediate(() => {
  console.log("setImmediate");
});

// 使用 process.nextTick 创建一个更高优先级的定时器
process.nextTick(() => {
  console.log("process.nextTick");
});

console.log("End");

运行上述代码可能会输出如下顺序：

Start
End
process.nextTick
setImmediate
Short setTimeout
// 几秒后...
Long setTimeout

请注意，实际输出可能因环境而异，因为事件循环的具体行为取决于当前系统的负载情况和其他因素。

Poll 阶段

Poll 阶段是 Node.js 事件循环中最重要的一个阶段，因为它负责处理绝大多数的 I/O 操作和异步回调。在这一阶段，Node.js 会检查 I/O 事件（如文件读写、网络请求等），并执行相应的回调函数。理解 Poll 阶段的工作机制对于优化应用程序性能至关重要。

Poll 阶段的主要任务

1. 检索新 I/O 事件：这是 Poll 阶段的核心任务。Node.js 使用底层操作系统提供的 I/O 多路复用机制（如 Linux 上的 epoll 或 macOS 上的 kqueue）来高效地监控多个文件描述符的状态变化。当某个文件描述符变得可读或可写时，就会触发相应的 I/O 事件。

2. 执行与 I/O 事件相关的回调：一旦检测到有新的 I/O 事件发生，Node.js 就会从轮询队列（poll queue）中取出对应的回调函数，并立即执行它们。这包括但不限于：

   • 文件系统操作的完成（如 fs.readFile() 的回调）
   • 网络连接的建立或关闭
   • 数据到达或发送完毕的通知

3. 处理定时器：尽管定时器回调主要由 Timers 阶段处理，但在某些情况下，Poll 阶段也会涉及到定时器。例如，如果在 Poll 阶段没有找到任何待处理的 I/O 事件，那么它可能会等待一段时间，直到下一个最近的定时器到期为止。

Poll 阶段的行为逻辑

• 非空轮询队列：如果轮询队列中有待处理的任务，事件循环会尽可能多地执行这些任务，但不会超过系统设定的最大限制（默认为 1000）。这意味着即使轮询队列中有大量任务，也不会一次性全部执行，而是分批处理以保证公平性和响应性。

• 空轮询队列：

  • 如果没有定时器即将到期，则事件循环会阻塞在此阶段，等待新的 I/O 事件出现。
  • 如果存在即将到期的定时器，事件循环会设置一个超时时间，使得它只等待足够长的时间让定时器到期，然后继续前进到下一个阶段。

示例代码展示 Poll 阶段行为

下面的例子展示了如何通过不同的异步操作来观察 Poll 阶段的行为：

const fs = require("fs");
const http = require("http");

console.log("Start");

// 定义一个 HTTP 服务器，在接收到请求时记录日志
const server = http.createServer((req, res) => {
  console.log("HTTP request received");
  res.end("Hello World\n");
});

// 启动服务器并监听端口
server.listen(3000, () => {
  console.log("Server is listening on port 3000");
});

// 执行一个异步的文件读取操作
fs.readFile(__filename, (err, data) => {
  if (err) throw err;
  console.log("File read complete");
});

// 设置一个短时间的定时器
setTimeout(() => {
  console.log("Timeout expired");
}, 500);

// 模拟长时间运行的任务，以观察其对事件循环的影响
setTimeout(() => {
  const start = Date.now();
  while (Date.now() - start < 2000) {
    // Do nothing, just wasting time...
  }
  console.log("Long running task completed");
}, 1000);

console.log("End");

在这个例子中，你可以看到：

• fs.readFile 的回调会在 Poll 阶段被执行，因为它是基于 I/O 的异步操作。
• setTimeout 回调会在 Timers 阶段被执行，除非它们被推迟到了下一个事件循环周期。
• 如果你发起一个 HTTP 请求到本地服务器（例如使用浏览器访问 http://localhost:3000），你会注意到 HTTP request received 日志出现在 File read complete 之后，这表明 HTTP 请求的处理也在 Poll 阶段进行。
• 最后，模拟的长时间运行任务会影响整个事件循环的效率，导致后续的回调延迟执行。

Timer 阶段与 Poll 阶段的关系

• Poll 阶段的超时控制：当 Poll 阶段没有待处理的 I/O 事件时，它会根据下一个最近的定时器来设置一个超时时间。这样可以避免无意义的长时间等待，同时也确保定时器能够及时触发。
• setImmediate 的特殊处理：虽然 setImmediate 通常在 Check 阶段执行，但如果 Poll 阶段没有其他任务并且轮询队列为空，则 setImmediate 回调会被提前执行，从而实现更快速的响应。

Check 阶段

Check 阶段是 Node.js 事件循环中的一个重要阶段，主要用于处理由 setImmediate 创建的回调。这个阶段确保了这些回调能够在适当的时机得到执行，通常是在当前事件循环周期结束之后、下一个周期开始之前。理解 Check 阶段的工作机制对于优化异步任务的调度和提高应用程序性能至关重要。

Check 阶段的主要任务

1. 执行 setImmediate 回调：这是 Check 阶段的核心任务。Node.js 在这个阶段会检查所有通过 setImmediate 注册的回调，并将它们逐一执行。与 setTimeout(fn, 0) 不同的是，setImmediate 的回调会在 Poll 阶段之后立即执行，而不是等待整个事件循环的一次完整迭代。

2. 高优先级异步操作：尽管 setImmediate 回调在 Check 阶段执行，但在某些情况下（例如当 Poll 阶段没有待处理的任务时），这些回调可能会被提前执行。这意味着 setImmediate 可以比 setTimeout(fn, 0) 更快地响应。

Check 阶段的行为逻辑

• 轮询队列为空时的提前执行：如果在 Poll 阶段没有找到新的 I/O 事件或其他任务需要处理，那么事件循环不会阻塞等待更多事件，而是直接进入 Check 阶段来执行 setImmediate 回调。这种行为使得 setImmediate 具有较高的优先级，能够更迅速地响应。

• 按顺序执行回调：即使有多个 setImmediate 回调注册，Node.js 也会按照它们注册的顺序依次执行，确保每个回调都能获得公平的执行机会。

• 避免无限循环：为了防止 setImmediate 回调导致事件循环陷入无限循环（即每个周期都有新的 setImmediate 被添加），Node.js 会对 setImmediate 回调的数量进行限制。一旦达到上限，后续的 setImmediate 将被推迟到下一个事件循环周期。

示例代码展示 Check 阶段行为

下面的例子展示了如何使用 setImmediate 并观察它在事件循环中的行为：

console.log("Start");

// 使用 process.nextTick 创建一个更高优先级的定时器
process.nextTick(() => {
  console.log("process.nextTick");
});

// 使用 setImmediate 创建一个高分辨率定时器
setImmediate(() => {
  console.log("setImmediate");
});

// 定义一个短时间的定时器
setTimeout(() => {
  console.log("Short setTimeout");
}, 0);

// 模拟长时间运行的任务，以观察其对事件循环的影响
setTimeout(() => {
  const start = Date.now();
  while (Date.now() - start < 2000) {
    // Do nothing, just wasting time...
  }
  console.log("Long running task completed");
}, 1000);

console.log("End");

运行上述代码可能会输出如下顺序：

Start
End
process.nextTick
setImmediate
Short setTimeout
// 几秒后...
Long running task completed

请注意，实际输出可能因环境而异，因为事件循环的具体行为取决于当前系统的负载情况和其他因素。

Check 阶段与 Poll 阶段的关系

• 提前执行条件：如前所述，如果 Poll 阶段没有其他任务并且轮询队列为空，则 setImmediate 回调会被提前执行，从而实现更快速的响应。
• 相对优先级：虽然 setImmediate 和 process.nextTick 都属于高分辨率定时器，但 process.nextTick 的优先级更高，因为它会在当前操作完成后立即执行，而不必等到下一个事件循环周期。

process.nextTick() 和 Promise 是 Node.js 中用于处理异步操作的两种机制，它们在事件循环中的行为有所不同。理解这两者的区别对于编写高效且可预测的异步代码非常重要。

process.nextTick()

process.nextTick() 是一种特殊的定时器机制，它允许你将回调函数插入到当前操作之后、下一个事件循环周期之前执行。这意味着 nextTick 回调会在当前操作（如 I/O 操作或脚本执行）完成后立即执行，但不会阻塞当前的操作。

特点

• 高优先级：nextTick 回调具有最高的优先级，甚至高于 setImmediate 和 setTimeout(fn, 0)。
• 非阻塞性：尽管 nextTick 回调会尽快执行，但它不会阻塞当前操作。
• 可能影响性能：如果频繁使用 nextTick，可能会导致事件循环陷入无限循环，因为每次操作后都会触发新的 nextTick 回调。

使用场景

• 修复错误：当遇到同步错误时，可以使用 nextTick 来推迟错误处理，避免抛出未捕获的异常。
• 分解任务：将大型任务分解成更小的部分，并通过 nextTick 分批执行，以保持事件循环的响应性。

示例代码

console.log("Start");

process.nextTick(() => {
  console.log("nextTick callback");
});

console.log("End");

输出顺序：

Start
End
nextTick callback

Promise

Promise 是一种用于处理异步操作的对象，它代表了一个异步操作的最终完成（或失败）及其结果值。与 process.nextTick() 不同的是，Promise 的回调是在当前事件循环周期结束后，在下一个 Poll 阶段开始前执行。

特点

• 标准化：Promise 是 ECMAScript 标准的一部分，不仅限于 Node.js，广泛应用于现代 JavaScript 编程。
• 链式调用：支持 .then()、.catch() 等方法进行链式调用，便于处理复杂的异步流程。
• 微任务队列：Promise 回调被放入微任务队列中，在每个事件循环周期结束时执行，确保所有同步代码都已执行完毕。

使用场景

• 异步操作：处理文件读写、网络请求等异步操作的结果。
• 并发控制：使用 Promise.all() 或 Promise.race() 来管理多个并发的异步操作。

示例代码

console.log("Start");

Promise.resolve().then(() => {
  console.log("Promise callback");
});

console.log("End");

输出顺序：

Start
End
Promise callback

nextTick vs Promise

特性	process.nextTick()	Promise
执行时机	当前操作完成后立即执行	当前事件循环周期结束后执行
优先级	最高优先级	微任务队列，较高优先级
是否阻塞当前操作	否	否
适用场景	错误处理、任务分解	异步操作、并发控制

事件循环中的位置

根据 Node.js 的事件循环模型：

1. Timer 阶段：处理到期的定时器回调。
2. I/O Callbacks 阶段：执行某些系统操作的回调。
3. Poll 阶段：检索新 I/O 事件；执行与此相关的回调。
4. Check 阶段：执行 setImmediate() 回调。
5. Close Callbacks 阶段：执行关闭回调。

• process.nextTick()：这些回调会在当前操作完成后立即执行，不依赖于具体的事件循环阶段。
• Promise 回调：这些回调会被放置在微任务队列中，在当前事件循环周期结束时执行，通常是在 Poll 阶段之前。

性能考虑

虽然 process.nextTick() 提供了更高的优先级，但这并不意味着应该滥用它。频繁使用 nextTick 可能会导致事件循环变得复杂，影响整体性能。相比之下，Promise 更加结构化和易于管理，适用于大多数异步编程需求。

示例代码：展示事件循环的不同阶段

下面的例子展示了如何利用不同的机制（setTimeout, setImmediate, I/O 操作）将回调安排在事件循环的不同阶段。

const fs = require("fs");

console.log("Start");

// 定时器回调，在 Timers 阶段执行
setTimeout(() => {
  console.log("setTimeout");
}, 0);

// setImmediate 回调，在 Check 阶段执行
setImmediate(() => {
  console.log("setImmediate");
});

// I/O 操作回调，在 Poll 阶段执行
fs.readFile(__filename, () => {
  console.log("fs.readFile");
});

console.log("End");

运行上述代码可能会输出如下顺序：

Start
End
fs.readFile
setImmediate
setTimeout

请注意，实际输出可能因环境而异，因为事件循环的具体行为取决于当前系统的负载情况和其他因素。

面试题

async function async1() {
  console.log("async1 start");
  await async2();
  console.log("async1 end");
}
async function async2() {
  console.log("async2");
}
console.log("script start");
setTimeout(function () {
  console.log("setTimeout0");
}, 0);
setTimeout(function () {
  console.log("setTimeout3");
}, 3);
setImmediate(() => {
  console.log("setImmediate");
});
process.nextTick(() => {
  console.log("nextTick");
});
async1();
new Promise(function (resolve) {
  console.log("promise1");
  resolve();
  console.log("promise2");
}).then(function () {
  console.log("promise3");
});
console.log("script end");

优化建议

• 避免长时间运行的同步操作：长时间运行的同步操作会阻塞事件循环，导致其他任务无法及时处理。尽量将耗时的任务移到后台进程中，或者使用异步 API 来代替。

• 合理使用 setImmediate 和 process.nextTick：如果你希望某个回调尽快被执行，可以考虑使用 process.nextTick，它会在当前操作完成后立即执行。然而，setImmediate 更适合用于将回调推迟到下一个事件循环周期。

• 正确管理定时器：确保你设置的定时器时间合理，避免过多的小间隔定时器占用过多资源。

• 监控和调试：使用工具如 node --inspect 或者第三方库来监控事件循环的状态，找出潜在的性能瓶颈。

总结

Node.js 的事件循环是其非阻塞 I/O 模型的基础，了解它的运作方式可以帮助开发者编写更加高效的应用程序。通过合理安排任务和优化代码结构，可以显著提升应用程序的性能和响应速度。