Node.js 多进程

Node.js 是一个单线程的 JavaScript 运行时环境，适合处理高并发的 I/O 操作，但由于其单线程特性，无法充分利用多核 CPU 的计算能力。为了解决这个问题，Node.js 提供了多进程支持，允许开发者创建多个工作进程来并行处理任务，从而提升性能。本文将用中文详细讲解 Node.js 多进程的实现方式和相关知识点。

---

1. 为什么需要多进程？

Node.js 的单线程模型在处理 CPU 密集型任务（如复杂计算、图像处理等）时会成为瓶颈，因为单个线程无法充分利用多核 CPU 的性能。多进程可以通过以下方式解决这个问题：

• 并行处理：每个进程可以运行在单独的 CPU 核心上，充分利用硬件资源。
• 提高稳定性：主进程和工作进程分离，工作进程崩溃不会直接影响主进程。
• 负载均衡：将任务分配到多个进程，降低单线程压力。

Node.js 提供了内置的 child_process 模块和 cluster 模块来实现多进程。

---

2. 实现多进程的两种主要方式

Node.js 中实现多进程主要依赖以下模块：

• child_process 模块：用于创建子进程，适合执行独立任务或运行非 Node.js 脚本。
• cluster 模块：专为 Node.js 应用设计，用于创建多个工作进程来分担 HTTP 请求等任务。

2.1 使用 child_process 模块

child_process 模块提供了创建子进程的功能，常见的 API 包括：

• fork()：专门用于创建 Node.js 子进程，子进程运行指定的 JavaScript 文件。
• spawn()：创建子进程运行任意命令（如 shell 脚本、Python 脚本等）。
• exec() 和 execFile()：执行命令并缓冲输出，适合短生命周期任务。

示例：使用 fork() 创建子进程

主进程文件（main.js）：

const { fork } = require('child_process');

// 创建子进程
const child = fork('child.js');

// 向子进程发送消息
child.send('Hello from parent!');

// 接收子进程的消息
child.on('message', (msg) => {
  console.log('收到子进程消息:', msg);
});

子进程文件（child.js）：

// 接收主进程的消息
process.on('message', (msg) => {
  console.log('收到主进程消息:', msg);
  // 回复主进程
  process.send('Hello from child!');
});

运行 node main.js，输出：

收到主进程消息: Hello from parent!
收到子进程消息: Hello from child!

特点：

• fork() 创建的子进程是独立的 Node.js 实例，有自己的 V8 引擎和事件循环。
• 主进程和子进程通过 IPC（进程间通信）进行消息传递。
• 适合运行独立的 JavaScript 任务，但需要手动管理进程间的通信和负载分配。

2.2 使用 cluster 模块

cluster 模块是 Node.js 专门为 HTTP 服务器设计的多进程方案。它通过一个主进程（Master）管理多个工作进程（Worker），主进程负责监听端口并将请求分发给工作进程。

示例：使用 cluster 模块创建多进程 HTTP 服务器

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length; // 获取 CPU 核心数

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);

  // 根据 CPU 核心数创建工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 监听工作进程退出事件
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
    // 可选择重启工作进程
    cluster.fork();
  });
} else {
  // 工作进程创建 HTTP 服务器
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Hello from worker ${process.pid}`);
  }).listen(8000);

  console.log(`工作进程 ${process.pid} 已启动`);
}

运行 node server.js，访问 http://localhost:8000，可以看到不同工作进程的响应。

特点：

• 主进程负责监听端口（如 8000），并通过轮询（Round-Robin）方式将请求分发给工作进程。
• 每个工作进程运行相同的代码，共享同一端口。
• 适合 Web 服务器场景，自动实现负载均衡。
• 当工作进程崩溃时，主进程可以监听到 exit 事件并重新启动进程。

---

3. 多进程的注意事项

3.1 进程间通信

• child_process.fork() 使用 IPC 通道进行通信，适合主进程与子进程之间的消息传递。
• cluster 模块也支持 IPC，工作进程可以通过 process.send() 向主进程发送消息。

3.2 负载均衡

• cluster 模块默认使用轮询算法分发请求，但可以通过配置（如 cluster.schedulingPolicy）调整分发策略。
• 对于 CPU 密集型任务，需手动分配任务到子进程，避免某个进程超载。

3.3 资源管理

• 每个进程都有独立的内存空间，创建过多进程可能导致内存占用过高。
• 根据 CPU 核心数合理设置工作进程数量，通常为 os.cpus().length。

3.4 错误处理

• 监控工作进程的 exit 事件，及时重启崩溃的进程。
• 使用 try-catch 或 process.on('uncaughtException') 处理未捕获的异常，避免进程崩溃。

---

4. 适用场景

• child_process：
• 执行独立任务，如运行 Python 脚本、处理文件转换等。
• 实现任务队列，将 CPU 密集型任务分发到子进程。
• cluster：
• 构建高并发的 Web 服务器。
• 处理大量 HTTP 请求，利用多核 CPU 提升吞吐量。

---

5. 实际案例：多进程任务分发

假设我们要处理一个 CPU 密集型任务（如计算 Fibonacci 数列），可以使用 child_process 分担计算任务。

主进程（main.js）：

const { fork } = require('child_process');

const tasks = [40, 41, 42, 43]; // 要计算的 Fibonacci 数列
const results = [];

tasks.forEach((n) => {
  const child = fork('fib.js');
  child.send(n);
  child.on('message', (result) => {
    results.push(result);
    console.log(`收到结果: Fibonacci(${result.n}) = ${result.value}`);
    if (results.length === tasks.length) {
      console.log('所有任务完成:', results);
    }
  });
});

子进程（fib.js）：

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

process.on('message', (n) => {
  const result = fibonacci(n);
  process.send({ n, value: result });
});

运行后，主进程将任务分发给多个子进程并收集结果，充分利用多核 CPU。

---

6. 总结

• 选择合适的模块：child_process 适合独立任务，cluster 适合 Web 服务器。
• 合理分配资源：根据 CPU 核心数和任务类型设置进程数量。
• 注意错误处理：确保进程崩溃不会影响整个应用。
• 进程间通信：利用 IPC 实现主进程与子进程的数据交互。

通过多进程，Node.js 可以突破单线程的限制，显著提升性能，特别适合高并发或 CPU 密集型场景。希望这篇讲解对你理解 Node.js 多进程有所帮助！

如果有更多问题或需要更深入的代码示例，请随时告诉我！