Node.js worker_threads:并发 vs 并行

一、核心结论

Node.js 的 worker_threads 模块实现的是 并行计算 ,而非传统意义上的"并发"。其通过操作系统级线程实现多核 CPU 的并行执行,同时保留 Node.js 单线程事件循环的并发模型。

二、关键概念解析

1. 并发(Concurrency) vs 并行(Parallelism)

  • 并发

    • 指系统同时处理多个任务的能力,但任务可能交替执行(如单核 CPU 通过时间片轮转)。
    • Node.js 主线程 的事件循环是典型的并发模型,通过非阻塞 I/O 和事件队列实现。
  • 并行

    • 指多个任务同时执行,需多核 CPU 支持,每个任务运行在独立核心上。
    • worker_threads 通过创建操作系统级线程实现并行计算。

2. Node.js 的线程模型

  • 主线程

    • 单线程,运行事件循环,处理 I/O 和事件回调。
    • 阻塞主线程会导致整个进程卡顿。
  • Worker 线程

    • 每个 Worker 线程是独立的 JavaScript 运行时,拥有自己的事件循环和堆内存。
    • 线程由操作系统的系统线程支持,可绑定到不同 CPU 核心,实现并行执行。

三、worker_threads 的并行机制

1. 多核利用

  • 默认线程数

    • Node.js 根据 CPU 核心数自动创建线程池(通常等于核心数)。
    • 例如,4 核 CPU 默认创建 4 个线程,每个线程绑定到一个核心。
  • 任务分配

    • 主线程通过 Worker 类创建子线程,并将任务通过 postMessage 分发。
    • 子线程执行任务后,通过 parentPort.postMessage 返回结果。

2. 线程调度

  • 操作系统调度

    • Worker 线程由操作系统调度到不同 CPU 核心,实现真正的并行执行。
    • 线程间通过 SharedArrayBuffer 或消息传递通信,避免阻塞主线程。
  • 示例:并行计算斐波那契数列

    javascript 复制代码
    // main.js
    const { Worker } = require('worker_threads');
    const numCPUs = require('os').cpus().length;
    
    for (let i = 0; i < numCPUs; i++) {
      const worker = new Worker('./fibonacciWorker.js');
      worker.postMessage(40); // 每个线程计算第40个斐波那契数
    }
    javascript 复制代码
    // fibonacciWorker.js
    const { parentPort } = require('worker_threads');
    
    function fibonacci(n) {
      return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    parentPort.on('message', (n) => {
      const result = fibonacci(n);
      parentPort.postMessage(result);
    });

四、对比传统并发模型

1. 事件循环(主线程)

  • 特点

    • 单线程,通过非阻塞 I/O 和事件队列实现高并发。
    • 适合 I/O 密集型任务(如网络请求、文件操作)。
  • 局限

    • CPU 密集型任务会阻塞事件循环,导致其他任务无法执行。

2. Worker 线程(并行计算)

  • 特点

    • 多线程,利用多核 CPU 并行执行 CPU 密集型任务。
    • 线程间通过消息传递或共享内存通信,避免阻塞主线程。
  • 适用场景

    • 大型计算(如加密、图像处理、机器学习)。
    • 并行化数据库查询或数据处理任务。

五、性能监控与验证

1. 监控 CPU 核心利用率

  • Linux

    bash 复制代码
    top -H -p <PID>  # 查看进程内所有线程的CPU使用率
  • Node.js

    javascript 复制代码
    const { threadId } = require('worker_threads');
    console.log(`Worker ${threadId} 正在运行`);

2. 并行计算验证

  • 示例:计算 π 的近似值(蒙特卡洛方法)

    javascript 复制代码
    // main.js
    const { Worker } = require('worker_threads');
    const numWorkers = 4;
    const totalSamples = 1e8;
    
    const workers = Array.from({ length: numWorkers }, (_, i) => {
      const worker = new Worker('./piWorker.js');
      worker.postMessage({ samples: totalSamples / numWorkers });
      return worker;
    });
    
    let results = [];
    workers.forEach((worker, i) => {
      worker.on('message', (result) => {
        results[i] = result;
        if (results.length === numWorkers) {
          const pi = results.reduce((sum, val) => sum + val) / numWorkers;
          console.log(`π ≈ ${pi}`);
        }
      });
    });
    javascript 复制代码
    // piWorker.js
    const { parentPort } = require('worker_threads');
    
    parentPort.on('message', ({ samples }) => {
      let inside = 0;
      for (let i = 0; i < samples; i++) {
        const x = Math.random();
        const y = Math.random();
        if (x * x + y * y <= 1) inside++;
      }
      parentPort.postMessage(4 * inside / samples);
    });

六、总结

  • worker_threads 是并行计算

    • 利用多核 CPU,通过操作系统级线程实现任务并行执行。
    • 适用于 CPU 密集型任务,避免阻塞主线程的事件循环。
  • 与主线程的并发模型互补

    • 主线程处理 I/O 和事件驱动的并发。
    • Worker 线程处理 CPU 密集型任务的并行计算。

通过合理使用 worker_threads,您可以充分发挥多核 CPU 的性能优势,构建高效、响应迅速的 Node.js 应用。