Node.js 中的同步与异步、阻塞与非阻塞

在学习网络编程与 Node.js 底层架构时,“同步 / 异步” 与 “阻塞 / 非阻塞” 是出现频率最高、但也最容易被混淆的概念。

网上很多技术博客往往用一句模糊的“同步就是按顺序执行,异步就是乱序执行”草草带过,甚至将“阻塞”和“同步”直接画上等号。这种含糊其辞的解释不仅经不起推敲,更无法让我们看清 Node.js 高并发事件驱动与 libuv 底层设计的真正精髓。

本文将跳出语焉不详的表面概念,回归经典操作系统 I/O 模型与 Node.js 运行时底层设计,彻底厘清这四个概念之间的边界与联动。


一、降维拆解:两个完全不同维度的正交概念

同步/异步、阻塞/非阻塞,实际上是从两个完全不同的关注维度来描述系统行为的。它们就像平面直角坐标系的 X 轴与 Y 轴,互为正交关系。

1
2
3
4
5
6
7
8
9
10
                  ▲ 阻塞 (Blocking)
│
同步阻塞 │ 异步阻塞 (如 select/epoll 多路复用)
(fs.readFileSync)│
──────────────────┼──────────────────► 异步 (Asynchronous)
│
同步非阻塞 │ 异步非阻塞
(非阻塞轮询检查)│ (Node.js 核心事件驱动模型)
│
▼ 非阻塞 (Non-blocking)

1. 同步 vs 异步:关注的是【消息通信机制与结果返回方式】

  • 同步(Synchronous):调用方发出一个调用后,在没有得到结果之前,该调用就不算完结。调用方必须主动等待、或者主动轮询该结果;
  • 异步(Asynchronous):调用方发出调用后,被调用方立刻返回响应,但此时结果尚未就绪。被调用方处理完毕后,通过**事件监听、信号通知或异步回调(Callback/Promise)**来主动通知调用方。

💡 核心差异:结果到底是你主动等出来的,还是被调用方事后通知你的。

2. 阻塞 vs 非阻塞:关注的是【调用方在等待结果时的线程状态】

  • 阻塞(Blocking):在调用结果返回之前,当前线程被操作系统挂起(休眠),让出 CPU 执行权,什么事也干不了,直到收到唤醒信号;
  • 非阻塞(Non-blocking):如果调用无法立即完成,该调用绝不挂起当前线程,而是立即返回一个状态码(如操作系统的 EAGAIN 或 EWOULDBLOCK)。当前线程继续保持活跃,可以转头执行其他代码。

💡 核心差异:在等待结果的这段时间里,当前 CPU 线程到底是在“原地睡觉”还是“继续干活”。


二、经典生活比喻:烧开水四部曲

为了更直观地感受这四种组合,我们来看一个经典的“烧水泡茶”例子:

模型组合对应场景行为
同步 + 阻塞你把水壶放到炉子上,搬个小板凳死死盯着水壶,期间什么事都不做(线程挂起),直到水烧开才起身。
同步 + 非阻塞你把水壶放到炉子上,转身去看书,但每隔 10 秒跑去厨房揭开壶盖看一眼水开了没有(主动轮询)。虽然你没有被挂起,但依然需要不断主动探查。
异步 + 阻塞你买了一个水开会响的鸣笛水壶,但你依然搬了个小板凳死坐在厨房盯着它响(主动等待信号)。对应底层类似 select/poll 阻塞在监听文件描述符上的场景。
异步 + 非阻塞你用带鸣笛的水壶烧水,打开火就直接回书房全身心写代码(线程继续执行),直到水烧开后水壶发出清脆的鸣笛声,你才去厨房倒水冲茶。这就是 Node.js 的编程范式!

三、Node.js 官方文档对于“阻塞”的严格界定

理解了上述通用计算机原理后,我们再来看 Node.js 官方文档关于阻塞的权威定义:

阻塞(Blocking) 是指在 Node.js 程序中,其它 JavaScript 语句的执行,必须等待一个**非 JavaScript 操作(例如 I/O 操作)**完成。这是因为当阻塞发生时,事件循环无法继续运行 JavaScript 代码。

在 Node.js 中,JavaScript 由于执行 CPU 密集型操作 而表现不佳,通常不被称为阻塞。在 Node.js 标准库中使用 libuv 的同步方法(以 Sync 结尾的方法)是最常用的阻塞操作。

—— Node.js 官方指南:阻塞与非阻塞一览

这里官方做了一个极其关键的技术区分:

1. 为什么“死循环”或“CPU 密集计算”不被称为严格意义上的“阻塞”?

在很多人的口误中,写个耗时 10 秒的复杂循环或者大量数学矩阵运算,导致后续请求卡住,大家也会脱口而出“服务被阻塞了”。但在 Node.js 底层术语中,这叫 CPU Starvation(事件循环被 CPU 饥饿饿死)。

  • 真正的阻塞(I/O Blocking):JavaScript 主线程调用了底层的系统 API(如 fs.readFileSync),主线程什么代码都没法执行,必须干等磁盘或内核返回,期间 CPU 利用率极低甚至为 0;
  • CPU 密集抢占(CPU-bound):JavaScript 主线程正在全力跑 V8 字节码,CPU 占用率飙到 100%,事件循环被完全霸占,导致微任务队列和宏任务队列得不到机会消费。

四、Node.js 核心机制:libuv 如何实现“异步非阻塞”?

众所周知,JavaScript 代码在主线程中是单线程执行的。既然是单线程,Node.js 凭什么能够做到高并发的异步非阻塞?

答案就藏在底层的 libuv 跨平台抽象库中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
             ┌─────────────────────────┐
│ V8 JavaScript 引擎 │
└────────────┬────────────┘
│
Node.js 核心绑定 (C++ Addon)
│
┌────────────▼────────────┐
│ libuv 事件循环 │
└──────┬───────────┬──────┘
│ │
网络 I/O (系统级驱动) │ │ 文件 I/O 与 DNS (线程池支撑)
│ │
┌────────────▼──┐ ┌──▼────────────────┐
│ Linux: epoll │ │ libuv Threadpool │
│ macOS: kqueue │ │ (默认 4 个工作线程)│
│ Win: IOCP │ └───────────────────┘
└───────────────┘

libuv 对不同类型的操作采用了不同的底层策略:

1. 网络 I/O:内核级原生多路复用(纯粹的非阻塞)

对于 HTTP、TCP、WebSocket、UDP 等网络操作,现代操作系统提供了极其强大的原生事件多路复用驱动:

  • Linux 上的 epoll;
  • macOS / BSD 上的 kqueue;
  • Windows 上的 IOCP。

当 Node.js 发起一个网络请求时,libuv 只是将该 Socket 文件描述符(fd)注册到内核监听树中,主线程立刻返回继续执行后续代码。当远程数据包到达网卡、内核缓冲区就绪后,内核会直接唤醒 libuv 事件循环,将对应的 I/O 回调压入轮询阶段执行。整个过程完全不需要额外开辟工作线程!

2. 文件 I/O 与 DNS:线程池伪装的异步(Threadpool)

与网络 I/O 不同,大多数操作系统的文件系统 API 并不支持真正的非阻塞读写(Linux 原生 AIO 存在很多限制和陷阱)。

为了在 JavaScript 层保持统一的非阻塞体验,libuv 在后台维护了一个默认包含 4 个线程的线程池(Threadpool):

  • 当你调用 fs.readFile() 时,主线程并没有做耗时读取,而是把这个任务扔给了 libuv 线程池中的某一个空闲工作线程;
  • 该工作线程以同步阻塞的方式从磁盘读取文件;
  • 读取完毕后,工作线程向主线程事件循环发送一个跨线程通信通知;
  • 主线程在下一轮事件循环的 Poll 阶段收到通知,执行你的回调函数。

📌 生产调优技巧:如果你的 Node.js 应用存在极高频的文件读写、密码学加解密(crypto.pbkdf2)或大量 DNS 域名解析,默认的 4 个线程极易被耗尽排队。可以通过环境变量调大线程池:

1
export UV_THREADPOOL_SIZE=16

五、代码实战:四种组合在 Node.js 中的具体体现

1. 同步阻塞示例

1
2
3
4
5
6
7
8
9
10
11
12
const fs = require('fs');

console.log('1. 开始同步读取文件...');
const start = Date.now();

// 同步阻塞方法,JavaScript 主线程在此硬等,事件循环彻底停滞
const data = fs.readFileSync('./big-file.zip');

console.log(`2. 读取完成,耗时: ${Date.now() - start} ms, 大小: ${data.length}`);
console.log('3. 执行后续业务逻辑');

// 输出严格按照 1 -> 2 -> 3 顺序,耗时期间无法处理任何其他 HTTP 请求

2. 异步非阻塞示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const fs = require('fs').promises;

console.log('1. 发起异步文件读取请求...');
const start = Date.now();

// 异步非阻塞,任务派发给 libuv 线程池后立刻返回 Promise
fs.readFile('./big-file.zip')
.then(data => {
console.log(`3. 异步回调返回,耗时: ${Date.now() - start} ms, 大小: ${data.length}`);
})
.catch(err => console.error(err));

console.log('2. 主线程无需等待,立即处理下一行代码!');

// 输出顺序: 1 -> 2 -> 3
// 在文件读取的几十毫秒到几秒钟内,主线程可以欢快地处理成千上万个网络请求!

3. 同步回调(容易被误解为异步的陷阱)

很多人以为“只要有 callback 就是异步”,这其实是一个严重的认知误区。比如数组的原生方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
console.log('A');

[1, 2, 3].forEach(item => {
console.log(`Item: ${item}`);
});

console.log('B');

// 实际输出:
// A
// Item: 1
// Item: 2
// Item: 3
// B

Array.prototype.forEach 接收的回调函数是纯正的同步回调。它只是把函数当作参数在当前调用栈中立即同步执行,根本没有将任务抛入事件循环队列,绝不能将其当作异步代码来理解。


六、生产避坑指南:Don’t Block the Event Loop

理解了同步、异步、阻塞与非阻塞之后,在实际架构与开发中,我们必须时刻遵守 Node.js 社区著名的黄金法则:“不要阻塞事件循环(Don’t Block the Event Loop)”。

1
2
3
4
5
6
7
8
9
10
11
12
                            [Node.js 主线程]
│
┌────────────────────┴────────────────────┐
▼ ▼
[安全: 异步 I/O] [危险: 阻塞事件循环]
* fs.promises.readFile() * fs.readFileSync()
* http.request() / fetch() * JSON.parse(超大 50MB 字符串)
* db.query() (走网络套接字) * crypto.pbkdf2Sync()
* timers (setTimeout / setImmediate) * 复杂的深度嵌套递归与低效正则 (ReDoS)
│ │
▼ ▼
事件循环高速轮转,单核支持万级并发 主线程瞬间卡死,所有后续请求全部超时超时

1. 杜绝在生产路由中使用任何 *Sync 方法

  • 类似 fs.readFileSync、crypto.scryptSync、zlib.gzipSync 等方法,只允许在应用服务启动初始化的几秒钟内(如读取配置文件、初始化密钥)使用。
  • 严禁在 HTTP 路由控制器或中间件中调用任何同步 I/O 方法,一个实例的一次同步读盘,就会让整个 Node.js 实例上挂起的所有客户端集体陪葬!

2. 警惕灾难性的 CPU 密集型任务

  • 超大 JSON 解析与序列化:解析一个 100MB 的 JSON 字符串会阻塞主线程数十甚至数百毫秒。可考虑流式解析工具(如 stream-json);
  • 正则表达式灾难性回溯(ReDoS):一个写得不规范的贪婪正则,面对恶意输入的畸形字符串,可能导致 CPU 算力陷入数分钟甚至数小时的指数级回溯爆炸;
  • 密码哈希与加解密:永远使用异步版本的 bcrypt.hash() 或 crypto.pbkdf2(),将计算压力安全下放给底层线程池。

七、总结与核心概念对照表

维度概念核心关注点典型表现在 Node.js 中的对应物
同步消息通信与结果交付方式发出调用后,等待拿到结果调用才返回const res = fn() 同步调用
异步消息通信与结果交付方式发出调用后立刻返回,后续由被调用方通知或执行回调Promise、async/await、事件监听
阻塞调用者等待期间的线程状态线程被内核直接挂起,让出 CPU 执行权fs.readFileSync、child_process.execSync
非阻塞调用者等待期间的线程状态线程不被挂起,无法立即完成时立即返回就绪状态网络套接字轮询、libuv 驱动的异步 I/O

Node.js 之所以能在高并发网络服务中展现出惊人的吞吐能力,其本质就在于它将单线程执行上下文与**操作系统的异步非阻塞 I/O(epoll/kqueue + libuv 线程池)**做了近乎完美的融合。

编写高质量 Node.js 代码的关键,就是把 I/O 操作全盘托付给底层的异步非阻塞管道,让轻盈的单线程事件循环永远保持高速飞转!


Node.js 中的同步与异步、阻塞与非阻塞
https://bubao.github.io/posts/1a87a4b.html
作者
一念
发布于
2021年11月21日
许可协议