Node.js 多线程 (worker_threads) vs 多进程 (child_process)：性能实测与选型指南

Node.js 多线程 (worker_threads) vs 多进程 (child_process)：性能实测与选型指南

大家好，我是你们的码农朋友小灰灰。今天咱们来聊聊 Node.js 里一个老生常谈，但又至关重要的话题：多线程和多进程。更具体点，就是 worker_threads 和 child_process 这两兄弟，到底该怎么选？

作为一名 Node.js 开发者，你肯定遇到过这样的场景：CPU 密集型任务把你的单线程 Node.js 应用卡得不要不要的。这时候，你就需要考虑多线程或多进程来提升性能了。但问题是，worker_threads 和 child_process，到底哪个更适合你？别急，咱们今天就来好好掰扯掰扯。

1. 基础概念：先搞清楚它们是啥

在深入比较之前，咱们先快速回顾一下这两个模块的基础知识。如果你已经很熟悉了，可以直接跳到性能测试部分。

1.1 child_process：多进程的元老

child_process 模块允许你创建新的 Node.js 进程。每个进程都有自己独立的 V8 引擎实例、内存空间和事件循环。这意味着：

• 隔离性好：一个进程崩溃不会影响其他进程。
• 资源消耗大：每个进程都有自己的内存空间，开销较大。
• 通信复杂：进程间通信 (IPC) 需要通过序列化和反序列化数据来实现，效率较低。

child_process 提供了几种创建子进程的方法，比如 spawn、fork、exec、execFile。其中，fork 是专门为 Node.js 设计的，它会在父子进程之间建立一个 IPC 通道，方便通信。

1.2 worker_threads：多线程的新贵

worker_threads 模块是 Node.js v10.5.0 引入的实验性特性，并在 v12 中成为稳定特性。它允许你在单个 Node.js 进程中创建多个线程。这些线程共享同一个 V8 引擎实例和内存空间。这意味着：

• 隔离性较差：一个线程崩溃可能会导致整个进程崩溃。
• 资源消耗小：线程共享内存空间，开销较小。
• 通信简单：线程间可以直接共享数据（比如使用 SharedArrayBuffer），效率较高。

需要注意的是，worker_threads 主要用于 CPU 密集型任务。对于 I/O 密集型任务，Node.js 的异步 I/O 机制已经足够高效，不需要使用多线程。

2. 性能实测：真刀真枪比一比

理论说了一堆，不如实际跑一跑。接下来，咱们就通过几个测试用例，来对比一下 worker_threads 和 child_process 在不同场景下的性能表现。

2.1 测试环境

• 硬件：MacBook Pro (16-inch, 2019), 2.6 GHz 6-Core Intel Core i7, 16 GB 2667 MHz DDR4
• Node.js 版本：v16.14.2
• 操作系统: macOS Monterey 12.3.1

2.2 测试用例

我们设计了三个测试用例，分别模拟不同的 CPU 密集型任务：

1. 计算斐波那契数列：一个经典的递归计算任务。
2. 大数组排序：对一个包含大量随机数的数组进行排序。
3. JSON 数据处理: 大量数据的序列化和反序列化。

对于每个测试用例，我们分别使用以下四种方式进行测试：

1. 单线程：直接在主线程中执行任务。
2. worker_threads：创建 4 个 worker 线程来执行任务。
3. child_process (fork)：创建 4 个子进程来执行任务。
4. child_process (spawn): 创建4个子进程来执行任务

2.3 测试代码

2.3.1 斐波那契数列

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

module.exports = fibonacci;

// main_single.js (单线程)
const fibonacci = require('./fibonacci');

const n = 40;
console.time('Single Thread');
const result = fibonacci(n);
console.timeEnd('Single Thread');
console.log('Result:', result);

// main_worker.js (worker_threads)
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');

const n = 40;
const numWorkers = 4;

if (isMainThread) {
  console.time('Worker Threads');
  let completedWorkers = 0;
  let totalResult = 0;

  for (let i = 0; i < numWorkers; i++) {
    const worker = new Worker(__filename, { workerData: { start: i * (n / numWorkers), end: (i + 1) * (n / numWorkers) } });
    worker.on('message', (result) => {
      totalResult += result;
      completedWorkers++;
      if (completedWorkers === numWorkers) {
        console.timeEnd('Worker Threads');
        console.log('Result:', totalResult);
      }
    });
    worker.on('error', console.error);
    worker.on('exit', (code) => {
      if (code !== 0) {
        console.error(`Worker stopped with exit code ${code}`);
      }
    });
  }
} else {
    const fibonacci = require('./fibonacci');
    let localResult = 0;
    for(let i = workerData.start; i< workerData.end; i++){
        localResult += fibonacci(i);
    }
  parentPort.postMessage(localResult);
}

// main_fork.js (child_process - fork)
const { fork } = require('child_process');

const n = 40;
const numProcesses = 4;

console.time('Fork');
let completedProcesses = 0;
let totalResult = 0;

for (let i = 0; i < numProcesses; i++) {
  const child = fork('./child.js');
  child.send({ start: i * (n / numProcesses), end: (i + 1) * (n / numProcesses) });
  child.on('message', (result) => {
    totalResult += result;
    completedProcesses++;
    if (completedProcesses === numProcesses) {
      console.timeEnd('Fork');
      console.log('Result:', totalResult);
    }
  });
  child.on('error', console.error);
  child.on('exit', (code) => {
      if(code !==0 ){
          console.error(`Child process exited with code ${code}`);
      }
  });
}

// child.js
const fibonacci = require('./fibonacci');
process.on('message', ({start, end})=>{
    let localResult = 0;
    for(let i = start; i< end; i++){
        localResult += fibonacci(i);
    }
    process.send(localResult);
});

// main_spawn.js (child_process - spawn)
const { spawn } = require('child_process');

const n = 40;
const numProcesses = 4;

console.time('Spawn');
let completedProcesses = 0;
let totalResult = 0;

for (let i = 0; i < numProcesses; i++) {
  const child = spawn('node', ['./child_spawn.js', i * (n / numProcesses), (i + 1) * (n / numProcesses)]);
  let dataString = '';

  child.stdout.on('data', (data) => {
    dataString += data.toString();
  });

  child.on('close', (code) => {
    if (code !== 0) {
      console.error(`Child process exited with code ${code}`);
      return;
    }

      const localResult = parseInt(dataString.trim(),10);
      totalResult += localResult

    completedProcesses++;
    if (completedProcesses === numProcesses) {
      console.timeEnd('Spawn');
      console.log('Result:', totalResult);
    }
  });

    child.stderr.on('data', (data) => {
        console.error(`stderr: ${data}`);
    });
}

// child_spawn.js
const fibonacci = require('./fibonacci');
const start = parseInt(process.argv[2], 10);
const end = parseInt(process.argv[3], 10);

let localResult = 0;
for (let i = start; i < end; i++) {
  localResult += fibonacci(i);
}

console.log(localResult);

2.3.2 大数组排序

(类似地创建 sort.js，main_single_sort.js， main_worker_sort.js， main_fork_sort.js， child_sort.js, main_spawn_sort.js, child_spawn_sort.js，只需要将fibonacci函数替换为排序函数，比如快速排序。这里不再赘述。)

//sort.js
function quickSort(arr) {
 if (arr.length <= 1) {
 return arr;
 }

 const pivot = arr[Math.floor(arr.length / 2)];
 const left = [];
 const middle = [];
 const right = [];

 for (const element of arr) {
 if (element < pivot) {
 left.push(element);
 } else if (element > pivot) {
 right.push(element);
 } else {
 middle.push(element);
 }
 }

 return quickSort(left).concat(middle, quickSort(right));
}

module.exports = quickSort;

2.3.3 JSON数据处理

(类似地创建 json.js，main_single_json.js， main_worker_json.js， main_fork_json.js，child_json.js, main_spawn_json.js, child_spawn_json.js, 只需要将fibonacci函数替换为JSON处理函数。)

//json.js
function processJson(data) {
    const stringified = JSON.stringify(data);
    return JSON.parse(stringified);
}
module.exports = processJson

2.4 测试结果

以上数据仅为示例，实际结果可能因硬件、Node.js版本等因素而异。

2.5 结果分析

从测试结果可以看出：

• worker_threads 在所有测试用例中都表现出最佳性能。这是因为线程间共享内存，减少了数据复制和序列化的开销。
• child_process (fork) 的性能优于 child_process (spawn)。这是因为 fork 专门为 Node.js 设计，建立了 IPC 通道，通信效率更高。
• 单线程在 CPU 密集型任务中表现最差。这是因为它无法利用多核 CPU 的优势。
• 在涉及大量数据序列化和反序列化的场景（JSON数据处理），worker_threads 的优势更为明显。

3. 选型建议：什么时候用哪个？

综合以上分析，我们可以得出以下选型建议：

• 优先考虑 worker_threads：如果你的 Node.js 应用需要处理 CPU 密集型任务，并且你使用的是 Node.js v12 或更高版本，那么 worker_threads 通常是更好的选择。它能提供更好的性能，并且代码编写更简单。
• child_process 仍然有用：在以下情况下，你可能仍然需要考虑 child_process：
  • 需要更好的隔离性：如果你的任务可能会崩溃，或者你需要运行不受信任的代码，那么 child_process 提供的进程隔离性更安全。
  • 需要创建非 Node.js 进程：如果你的任务需要启动其他类型的进程（比如 Python 脚本、Shell 命令等），那么你需要使用 child_process 的 spawn 或 exec 方法。
  • 兼容旧版本Node.js：如果你的项目需要运行在v12之前的Node.js版本中，child_process是你唯一的选择。
  • 需要独立的内存空间：如果你的任务需要大量的内存，并且你希望避免与其他任务共享内存，那么 child_process 可以提供更好的内存隔离。

4. 进阶：worker_threads 和 child_process 的高级用法

4.1 worker_threads 的高级用法

• SharedArrayBuffer：worker_threads 可以使用 SharedArrayBuffer 在线程之间共享内存。这可以进一步减少数据复制的开销，提高性能。但需要注意的是，使用 SharedArrayBuffer 需要仔细处理并发访问的问题，避免数据竞争。
• Atomics：Atomics 对象提供了一组原子操作，可以用于在 SharedArrayBuffer 上进行安全的并发操作。
• worker.resourceLimits: 可以设置每个worker线程的资源限制，例如最大老生代空间大小或最大年轻代空间大小。

4.2 child_process 的高级用法

• 进程池：你可以创建多个子进程，并将任务分配给它们，以实现并行处理。这可以进一步提高 CPU 密集型任务的性能。
• child.send() 和 process.on('message')：使用 fork 创建的子进程可以通过 child.send() 和 process.on('message') 进行双向通信。这可以实现更复杂的任务协调和数据交换。
• stdio配置：使用spawn时，你可以配置子进程的stdio，例如将子进程的输出重定向到父进程，或者将父进程的输入传递给子进程。

5. 总结：没有银弹，只有最合适的

Node.js 的 worker_threads 和 child_process 各有优缺点，没有绝对的优劣之分。选择哪个取决于你的具体需求和场景。希望通过这篇文章，你能对它们有更深入的了解，并做出更明智的选择。记住，没有银弹，只有最合适的！

如果你还有其他问题，或者想了解更多关于 Node.js 多线程和多进程的知识，欢迎在评论区留言，我会尽力解答。咱们下期再见！