【Node】单线程的Node.js为什么可以实现多线程？

前言

很多刚接触 Node.js 的开发者都会有一个疑问：既然 Node.js 是单线程的，为什么又能使用 Worker Threads 这样的多线程模块呢？

今天我们就来解开这个看似矛盾的技术谜题。

👀 脑海里先有个印象：【Node.js 主线程】是单线程的，但【可以通过其他方式】实现并行处理

什么是 Node.js 的"单线程"？

事件循环（Event Loop）机制

1// 这是一个简单的 Node.js 程序
2console.log('开始执行')
3
4setTimeout(() => {
5    console.log('定时器回调')
6}, 1000)
7
8console.log('继续执行')
9
10// 输出顺序：
11// 开始执行
12// 继续执行
13// 定时器回调
14

核心特点：

• Node.js 有一个主线程负责执行 JavaScript 代码
• 这个主线程运行着事件循环，按顺序处理任务
• I/O 操作（文件读写、网络请求等）被【委托给系统底层】，不阻塞主线程

单线程的优势

1// 单线程模型简单易懂
2let count = 0
3
4function increment() {
5    count++
6    console.log(count)
7}
8
9increment() // 输出 1
10increment() // 输出 2
11// 不用担心多线程的竞争条件问题
12

优点：

• ✅ 编程模型简单
• ✅ 避免复杂的线程同步问题
• ✅ 上下文切换开销小

那为什么还需要多线程？

单线程的局限性

1// CPU 密集型任务会阻塞事件循环
2function heavyCalculation() {
3    let result = 0
4    for (let i = 0; i < 1000000000; i++) {
5        result += Math.sqrt(i) * Math.sin(i)
6    }
7    return result
8}
9
10console.log('任务开始')
11heavyCalculation() // 在这期间，其他任务都无法执行！
12console.log('任务结束，但用户界面会卡住')
13

问题暴露：

• 一个复杂的计算任务会阻塞整个应用程序
• 无法充分利用多核 CPU 的性能
• 对于计算密集型应用性能受限

解开谜题：Node.js 的多线程能力

底层真相：Node.js 不是完全单线程！！！

实际上，Node.js 的架构是下面这样的：

1┌─────────────────────────────┐
2│         Node.js 进程         │
3├─────────────────────────────┤
4│  ┌─────────────────────┐    │
5│  │    JavaScript主线程   │ ← 我们写的代码在这里运行！
6│  └─────────────────────┘    │
7│                             │
8│  ┌─────────────────────┐    │
9│  │    libuv线程池       │ ← 处理文件I/O、DNS等
10│  └─────────────────────┘    │
11│                             │
12│  ┌─────────────────────┐    │
13│  │   V8后台线程         │ ← 垃圾回收等
14│  └─────────────────────┘    │
15└─────────────────────────────┘
16

重点需要理解的内容：

• JavaScript 执行环境是单线程的。
• 但 Node.js 运行时本身使用了多线程
• libuv 库提供了线程池来处理某些类型的 I/O 操作

补充知识：

Node.js 的 JavaScript 执行环境确实是单线程的，这意味着你的 JavaScript 代码是在一个主线程中顺序执行的，这个主线程运行着事件循环机制。

然而，Node.js 运行时本身是基于 C++ 的，它内部使用了多线程技术：libuv 这个底层库提供了一个线程池，当 JavaScript 代码执行到某些特定的异步 I/O 操作（如文件系统操作、DNS 查找等）时，这些任务会被提交到 libuv 的线程池中由后台线程执行，从而避免阻塞 JavaScript 主线程；

此外，V8 引擎也会使用一些后台线程来处理垃圾回收等任务。

所以，JavaScript 代码的执行是单线程的，但 Node.js 平台的底层实现是多线程的。

Worker Threads 的工作原理

1const {Worker, isMainThread} = require('worker_threads')
2
3if (isMainThread) {
4    // 这是在主线程
5    console.log('主线程 ID:', process.pid)
6
7    // 创建新的工作线程
8    const worker = new Worker(
9        `
10        const { parentPort } = require('worker_threads');
11        console.log('工作线程中执行');
12        parentPort.postMessage('来自工作线程的消息');
13    `,
14        {eval: true}
15    )
16
17    worker.on('message', msg => {
18        console.log('主线程收到:', msg)
19    })
20} else {
21    // 这是在工作线程中（这段代码不会在这里执行）
22}
23

工作机制：

1. 每个 Worker Thread 都有自己独立的 JavaScript 执行环境
2. 工作线程与主线程内存不共享（但可以通过 SharedArrayBuffer 共享）
3. 线程间通过消息传递进行通信

为什么这样设计？

历史演进

1. 最初设计：专注于 I/O 密集型任务，单线程+事件循环足够高效
2. 需求变化：JavaScript 应用场景扩展到计算密集型领域
3. 技术演进：引入 Worker Threads 来弥补单线程的不足

设计哲学

1// 正确的使用方式：主线程负责协调，工作线程负责计算
2class TaskManager {
3    async processBigData(data) {
4        // 主线程：任务分发和结果收集
5        const promises = data.chunks.map(chunk => this.runInWorker('./calculation-worker.js', chunk))
6
7        // 不阻塞主线程，可以同时处理其他请求
8        const results = await Promise.all(promises)
9        return this.aggregateResults(results)
10    }
11}
12

这样设计的好处：

• 保持主线程的轻量和响应性
• 将重型计算卸载到工作线程
• 既享受单线程的简单性，又获得多线程的计算能力

下面举一些现实开发中的应用 🌰

🌰 例子 1：Web 服务器中的计算任务

1const express = require('express')
2const {Worker} = require('worker_threads')
3const app = express()
4
5app.get('/fast-request', (req, res) => {
6    // 快速响应，不阻塞
7    res.json({status: 'ok', message: '立即返回'})
8})
9
10app.get('/heavy-calculation', async (req, res) => {
11    // 重型计算交给工作线程
12    const result = await runInWorker('./heavy-math.js', req.query.data)
13    res.json({result})
14})
15
16// 主线程始终保持响应
17

🌰 例子 2：数据处理管道

1async function processLargeDataset(dataset) {
2    const chunkSize = Math.ceil(dataset.length / 4) // 分成4份
3    const workers = []
4
5    for (let i = 0; i < 4; i++) {
6        const chunk = dataset.slice(i * chunkSize, (i + 1) * chunkSize)
7        workers.push(createWorker('./data-processor.js', chunk))
8    }
9
10    // 并行处理，大大加快速度
11    const results = await Promise.all(workers)
12    return results.flat()
13}
14

✍️ 总结

核心要点回顾

1. Node.js 的单线程指的是 JavaScript 执行环境是单线程的
2. 底层实现使用了多线程技术来处理 I/O 等操作
3. Worker Threads 让我们能够在应用层面使用多线程能力
4. 设计目标是保持【主线程的响应性】，同时获得并行计算的好处

👍 最佳实践

• 常规 I/O 操作：使用原生 Node.js 单线程 + 异步模式
• CPU 密集型任务：使用 Worker Threads 避免阻塞主线程
• 高并发 Web 服务：使用 Cluster 模块充分利用多核 CPU

😎 回答标题的问题

Node.js 既是单线程的，又支持多线程，这并不矛盾：

• 单线程：指 JavaScript 代码的执行方式，简化编程模型
• 多线程能力：通过底层库和 Worker Threads 模块提供，解决性能瓶颈

《【Node】单线程的Node.js为什么可以实现多线程？》 是转载文章，点击查看原文。