Node.js 事件循环（最佳实践）

Node.js 事件循环：理解异步编程的核心机制

在学习 Node.js 的过程中，你可能遇到过这样的困惑：明明代码按顺序写了，但输出结果却不是按顺序来的。比如一个耗时的文件读取操作，后面紧接着的代码却先执行了。这背后，正是 Node.js 事件循环在起作用。

如果你是初学者，这种“看似混乱”的执行顺序可能会让你感到迷茫。但如果你能真正理解 Node.js 事件循环的运行机制，就能轻松驾驭异步编程，写出高效、可维护的代码。

本文将带你从零开始，一步步拆解 Node.js 事件循环的工作原理。通过真实代码示例和形象比喻，让你不再被“异步”吓倒，反而能主动掌控程序流程。

什么是事件循环？它为什么重要？

简单来说，事件循环是 Node.js 实现异步非阻塞 I/O 的核心机制。它让 Node.js 能在一个线程中处理大量并发请求，而不会因为某个操作（如读文件、网络请求）卡住整个程序。

想象一下，你去餐厅点餐。传统方式是：你坐下后，服务员带你去厨房，你必须等厨师做完菜才能离开。这就像传统的同步编程——阻塞等待。

而现代餐厅的模式是：你点完餐，服务员给你一个号码牌，然后你去旁边坐着等。厨师做菜时，服务员继续接待其他客人。等菜好了，服务员叫号通知你。这正是 Node.js 事件循环的运作方式：不等待，只记录，事后通知。

在 Node.js 中，所有异步操作（如 fs.readFile、http.get）都会被放入事件循环的“任务队列”中，主程序继续执行后续代码。当异步操作完成，事件循环会从队列中取出回调函数执行。

事件循环的六大阶段详解

Node.js 事件循环由多个阶段组成，每个阶段都有特定的任务。理解这些阶段，是掌握异步行为的关键。

宏任务队列与微任务队列的区别

在深入阶段前，必须先搞清楚两个概念：宏任务（Macro Task） 和 微任务（Micro Task）。

宏任务：包括 setTimeout、setInterval、I/O 操作、UI 渲染等。
微任务：包括 Promise 的 then/catch、process.nextTick、MutationObserver 等。

关键区别在于：每个阶段执行完后，会优先清空微任务队列，再进入下一阶段。

console.log('1');

setTimeout(() => {
  console.log('2');
}, 0);

Promise.resolve().then(() => {
  console.log('3');
});

console.log('4');

// 输出顺序：1 4 3 2

解释：

console.log('1')：同步执行，输出 1
setTimeout(...)：宏任务，放入宏任务队列，延迟 0ms
Promise.resolve().then(...)：微任务，放入微任务队列
console.log('4')：同步执行，输出 4
此时宏任务队列未执行，但微任务队列有任务，优先执行 3
微任务清空后，进入下一阶段，执行 setTimeout 回调，输出 2

这个例子完美展示了微任务优先于宏任务执行的机制。

第一阶段：timers（定时器）

这个阶段处理 setTimeout 和 setInterval。

console.log('开始执行定时器');

setTimeout(() => {
  console.log('定时器触发：1000ms 后');
}, 1000);

setTimeout(() => {
  console.log('定时器触发：500ms 后');
}, 500);

// 输出：
// 开始执行定时器
// 定时器触发：500ms 后
// 定时器触发：1000ms 后

注意：setTimeout 的延迟时间是最小等待时间，不是精确时间。系统可能因为其他任务占用 CPU 而延迟执行。

第二阶段：pending callbacks（待处理回调）

这个阶段处理 I/O 回调中那些被延迟的回调，比如某些网络错误或系统调用失败的回调。

通常我们不会直接使用这个阶段，但它在底层处理中起作用。例如，socket.on('error') 的回调可能在这里执行。

第三阶段：idle, prepare（空闲和准备）

这个阶段主要用于内部准备，对开发者来说基本不可见。你可以理解为“系统在整理行装，准备迎接下一个任务”。

第四阶段：poll（轮询）

这是最核心的阶段之一。Node.js 在这个阶段检查是否有 I/O 任务可以执行。

如果当前没有定时器、微任务或待处理的回调，事件循环会在此阶段等待 I/O 事件，直到有新的任务到来。

console.log('进入 poll 阶段');

const fs = require('fs');

fs.readFile('./example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log('文件读取完成：', data);
});

// 事件循环会在此阶段等待文件读取完成，不会阻塞
// 其他代码可继续执行
console.log('文件读取请求已发出，等待结果');

// 输出：
// 进入 poll 阶段
// 文件读取请求已发出，等待结果
// 文件读取完成：Hello World

这个阶段体现了 Node.js 非阻塞的本质：发出请求后立刻返回，不等结果。

第五阶段：check（检查）

这个阶段处理 setImmediate() 的回调。

setImmediate() 的执行时机在 poll 阶段之后，但在下一次事件循环开始之前。

console.log('开始执行 setImmediate');

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

setTimeout(() => {
  console.log('setTimeout 回调执行');
}, 0);

// 输出顺序：
// 开始执行 setImmediate
// setImmediate 回调执行
// setTimeout 回调执行

虽然 setTimeout 延迟为 0，但 setImmediate 仍然优先执行。这是因为它被设计为“尽快执行”，而 setTimeout 有最小延迟限制。

第六阶段：close callbacks（关闭回调）

这个阶段处理 socket.on('close') 等关闭事件的回调。通常用于清理资源。

实际案例：模拟并发请求处理

下面是一个真实场景：模拟多个 HTTP 请求，用事件循环高效处理。

const http = require('http');

console.log('开始发起 3 个并发请求');

// 模拟 3 个异步请求
const urls = [
  'https://jsonplaceholder.typicode.com/posts/1',
  'https://jsonplaceholder.typicode.com/posts/2',
  'https://jsonplaceholder.typicode.com/posts/3'
];

// 用 Promise 封装请求
function fetchUrl(url) {
  return new Promise((resolve, reject) => {
    http.get(url, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve(data));
      res.on('error', reject);
    }).on('error', reject);
  });
}

// 并发执行
Promise.all(urls.map(fetchUrl))
  .then(results => {
    console.log('所有请求完成，共收到', results.length, '条数据');
    results.forEach((data, index) => {
      console.log(`第 ${index + 1} 个响应：`, JSON.parse(data).title);
    });
  })
  .catch(err => {
    console.error('请求失败：', err);
  });

console.log('请求已发出，事件循环继续处理其他任务');

输出：

开始发起 3 个并发请求
请求已发出，事件循环继续处理其他任务
所有请求完成，共收到 3 条数据
第 1 个响应： sunt aut facere repellat provident occaecati excepturi optio reprehenderit
第 2 个响应： qui est esse
第 3 个响应： ea aperiam consequatur quisquam voluptatum

这个例子展示了事件循环如何在不阻塞主线程的情况下，同时处理多个网络请求。每个请求都进入事件循环的宏任务队列，当响应返回时，回调函数被加入微任务队列，最终执行。

常见陷阱与最佳实践

陷阱一：误以为 setTimeout(0) 立即执行

console.log('1');

setTimeout(() => {
  console.log('2');
}, 0);

console.log('3');

// 输出：1 3 2

虽然延迟为 0，但它仍是一个宏任务，必须等到当前执行栈清空、微任务队列处理完毕后才执行。

陷阱二：混用 Promise 和 setTimeout

console.log('A');

Promise.resolve().then(() => {
  console.log('B');
});

setTimeout(() => {
  console.log('C');
}, 0);

console.log('D');

// 输出：A D B C

Promise 的 then 是微任务，setTimeout 是宏任务。微任务优先执行。

最佳实践建议

优先使用 Promise 和 async/await，代码更清晰。
setImmediate() 用于需要“尽快执行”的场景，如避免长时间阻塞。
使用 process.nextTick() 处理极早期的异步任务，但要避免滥用，因为它可能造成无限循环。
避免在事件循环中执行耗时同步操作，保持主线程响应。

总结：掌控你的程序流程

Node.js 事件循环不是魔法，而是一套精密设计的调度机制。它让 JavaScript 能在单线程中实现高并发，是 Node.js 高性能的基石。

掌握事件循环，意味着你能：

预测代码执行顺序
避免异步陷阱
写出高效、可维护的异步代码

无论你是初学者还是中级开发者，深入理解 Node.js 事件循环，都是迈向专业的重要一步。下次当你看到代码输出顺序“不合逻辑”时，不妨停下来，问自己：事件循环现在在哪个阶段？ 这个问题，能帮你解开几乎所有异步难题。