嗨，我完全懂你的困扰——你现在的代码让每个子进程都跑了一遍完整的150次计算，相当于重复做了16遍相同的活，耗时当然翻倍！咱们要做的是把任务拆分给不同的子进程，让每个核心只干自己的那一份，这样才能真正榨干16核的性能。下面给你一套可行的方案：

核心思路 #

1. 主进程负责拆分你的150个超市计算任务，分成16份（对应16核）
2. 每个子进程只接收自己的任务块，完成计算后把结果发回主进程
3. 主进程收集所有子进程的结果，最后汇总得到最终输出

完整代码示例 #

第一步：把待处理的数组单独抽出来（tasks.js） #

先把你的超市数组单独放到一个文件里，方便主进程拆分：

// tasks.js
module.exports = [
  {name: "target"},
  {name:"walmart"},
  // ...剩下的148个对象，包括空对象
];

第二步：改造Cluster控制文件（cluster.js） #

这是核心逻辑，主进程拆分任务、分发、收集结果，子进程处理任务：

const cluster = require('cluster');
const numCPUs = require('os').cpus().length; // 自动获取CPU核心数，比硬写16更灵活
const tasks = require('./tasks');

// 主进程逻辑（Node.js v16+用isPrimary，旧版本用isMaster）
if (cluster.isPrimary) {
  console.log(`主进程 ${process.pid} 启动，准备拆分任务到${numCPUs}个核心`);
  
  // 把150个任务拆分成和核心数匹配的小块
  const taskChunks = splitTasksIntoChunks(tasks, numCPUs);
  const finalResults = [];
  let completedWorkers = 0;

  // 给每个核心分配一个子进程和对应的任务块
  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork();
    
    // 发送任务块给子进程
    worker.send({ chunk: taskChunks[i] });

    // 监听子进程返回的计算结果
    worker.on('message', (resultChunk) => {
      finalResults.push(...resultChunk);
      completedWorkers++;

      // 所有子进程都完成后，处理最终结果
      if (completedWorkers === numCPUs) {
        console.log('所有计算完成！最终结果汇总：', finalResults);
        cluster.disconnect(); // 关闭所有子进程，释放资源
      }
    });

    // 处理子进程可能出现的错误
    worker.on('error', (err) => {
      console.error(`子进程 ${worker.process.pid} 出错:`, err);
    });
  }

  // 数组拆分工具函数：把大数组均匀分成n块
  function splitTasksIntoChunks(arr, numChunks) {
    const chunks = [];
    const chunkSize = Math.ceil(arr.length / numChunks);
    for (let i = 0; i < arr.length; i += chunkSize) {
      chunks.push(arr.slice(i, i + chunkSize));
    }
    return chunks;
  }
} else {
  // 子进程逻辑：接收任务、执行计算、返回结果
  process.on('message', (msg) => {
    const { chunk } = msg;
    const resultChunk = [];

    // 处理当前子进程分配到的任务块
    for (const supermarket of chunk) {
      // 跳过没有name属性的空对象，避免报错
      if (supermarket.name) {
        const calculationResult = calculationFunction(supermarket.name);
        resultChunk.push({ name: supermarket.name, result: calculationResult });
      }
    }

    // 把结果发回主进程
    process.send(resultChunk);
    // 任务完成后退出子进程，避免资源占用
    process.exit();
  });

  // 这里替换成你实际的calculationFunction
  function calculationFunction(supermarketName) {
    // 模拟耗时计算，比如复杂的数值运算、数据处理
    let total = 0;
    for (let i = 0; i < 1e7; i++) {
      total += i * supermarketName.length;
    }
    return total;
  }
}

关键说明 #

• 任务拆分：通过splitTasksIntoChunks函数把150个任务均匀分给16个核心，每个子进程只处理8-9个任务（150/16≈9.375），不会重复计算
• 进程通信：用process.send()和message事件实现主进程和子进程的任务、结果传递
• 资源清理：子进程完成任务后主动退出，主进程在所有任务完成后关闭所有子进程，避免内存泄漏
• 容错处理：跳过空对象、监听子进程错误，避免单个任务失败导致整个流程崩溃

这样修改后，你的16核就会同时工作，每个核心处理自己的任务块，总耗时会大幅降低——再也不会出现重复计算拖慢速度的问题啦！

内容的提问来源于stack exchange，提问作者betzebube1000