Node.js 多進程處理CPU密集任務的實現(xiàn)

更新時間：2019年05月26日 14:12:26 作者：Svend

這篇文章主要介紹了Node.js 多進程處理CPU密集任務的實現(xiàn)，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

Node.js 單線程與多進程

大家都知道 Node.js 性能很高，是以異步事件驅動、非阻塞 I/O 而被廣泛使用。但缺點也很明顯，由于 Node.js 是單線程程序，如果長時間運算，會導致 CPU 不能及時釋放,所以并不適合 CPU 密集型應用。

當然，也不是沒有辦法解決這個問題。雖然 Node.js 不支持多線程，但是可創(chuàng)建多子進程來執(zhí)行任務。
Node.js 提供了 child_process 和 cluster 兩個模塊可用于創(chuàng)建多子進程

下面我們就分別使用單線程和多進程來模擬查找大量斐波那契數(shù)進行 CPU 密集測試

以下代碼是查找 500 次位置為 35 的斐波那契數(shù)(方便測試，定了一個時間不需要太長也不會太短的位置)

單線程處理

代碼：single.js

function fibonacci(n) {
 if (n == 0 || n == 1) {
  return n;
 } else {
  return fibonacci(n - 1) + fibonacci(n - 2);
 }
}

let startTime = Date.now();
let totalCount = 500;
let completedCount = 0;
let n = 35;

for (let i = 0; i < totalCount; i++) {
 fibonacci(n);
 completedCount++;
 console.log(`process: ${completedCount}/${totalCount}`);
}
console.log("👏 👏 👏 👏 👏 👏 👏 👏 👏 👏");
console.info(`任務完成，用時: ${Date.now() - startTime}ms`);
console.log("👏 👏 👏 👏 👏 👏 👏 👏 👏 👏");

執(zhí)行node single.js 查看結果

在我的電腦上顯示結果為44611ms(電腦配置不同也會有差異)。

...
process: 500/500
👏 👏 👏 👏 👏 👏 👏 👏 👏 👏
任務完成，用時: 44611ms
👏 👏 👏 👏 👏 👏 👏 👏 👏 👏

查找 500 次需要 44 秒，太慢了?？上攵绻恢酶?，數(shù)量更多...

那我們來嘗試用多進程試試 ⬇️

多進程

采用 cluster 模塊，Master-Worker 模式來測試

共 3 個 js，分別為主線程代碼：master.js、子進程代碼：worker.js、入口代碼：cluster.js(入口可無需單獨寫一個 js、這里是為了看起來更清楚一些)

主線程代碼：master.js

const cluster = require("cluster");
const numCPUs = require("os").cpus().length;

// 設置子進程執(zhí)行程序
cluster.setupMaster({
 exec: "./worker.js",
 slient: true
});

function run() {
 // 記錄開始時間
 const startTime = Date.now();
 // 總數(shù)
 const totalCount = 500;
 // 當前已處理任務數(shù)
 let completedCount = 0;
 // 任務生成器
 const fbGenerator = FbGenerator(totalCount);

 if (cluster.isMaster) {
  cluster.on("fork", function(worker) {
   console.log(`[master] : fork worker ${worker.id}`);
  });
  cluster.on("exit", function(worker, code, signal) {
   console.log(`[master] : worker ${worker.id} died`);
  });

  for (let i = 0; i < numCPUs; i++) {
   const worker = cluster.fork();

   // 接收子進程數(shù)據(jù)
   worker.on("message", function(msg) {
    // 完成一個，記錄并打印進度
    completedCount++;
    console.log(`process: ${completedCount}/${totalCount}`);

    nextTask(this);
   });

   nextTask(worker);
  }
 } else {
  process.on("message", function(msg) {
   console.log(msg);
  });
 }

 /**
  * 繼續(xù)下一個任務
  *
  * @param {ChildProcess} worker 子進程對象，將在此進程上執(zhí)行本次任務
  */
 function nextTask(worker) {
  // 獲取下一個參數(shù)
  const data = fbGenerator.next();
  // 判斷是否已經(jīng)完成，如果完成則調用完成函數(shù)，結束程序
  if (data.done) {
   done();
   return;
  }
  // 否則繼續(xù)任務
  // 向子進程發(fā)送數(shù)據(jù)
  worker.send(data.value);
 }

 /**
  * 完成，當所有任務完成時調用該函數(shù)以結束程序
  */
 function done() {
  if (completedCount >= totalCount) {
   cluster.disconnect();
   console.log("👏 👏 👏 👏 👏 👏 👏 👏 👏 👏");
   console.info(`任務完成，用時: ${Date.now() - startTime}ms`);
   console.log("👏 👏 👏 👏 👏 👏 👏 👏 👏 👏");
  }
 }
}

/**
 * 生成器
 */
function* FbGenerator(count) {
 var n = 35;
 for (var i = 0; i < count; i++) {
  yield n;
 }
 return;
}

module.exports = {
 run
};

1.這里是根據(jù)當前電腦的邏輯 CPU 核數(shù)來創(chuàng)建子進程的，不同電腦數(shù)量也會不一樣，我的 CPU 是 6 個物理核數(shù)，由于支持超線程處理，所以邏輯核數(shù)是 12，故會創(chuàng)建出 12 個子進程

2.主線程與子進程之間通信是通過send方法來發(fā)送數(shù)據(jù)，監(jiān)聽message事件來接收數(shù)據(jù)

3.不知道大家有沒有注意到我這里使用了 ES6 的 Generator 生成器來模擬生成每次需要查找的斐波那契數(shù)位置(雖然是寫死的 😂，為了和上面的單線程保證統(tǒng)一)。這么做是為了不讓所有任務一次性扔出去，因為就算扔出去也會被阻塞，還不如放在程序端就給控制住，完成一個，放一個。

子進程代碼：worker.js

function fibonacci(n) {
 if (n == 0 || n == 1) {
  return n;
 } else {
  return fibonacci(n - 1) + fibonacci(n - 2);
 }
}

// 接收主線程發(fā)送過來的任務，并開始查找斐波那契數(shù)
process.on("message", n => {
 var res = fibonacci(n);
 // 查找結束后通知主線程，以便主線程再度進行任務分配
 process.send(res);
});
入口代碼：cluster.js
// 引入主線程js，并執(zhí)行暴露出來的run方法
const master = require("./master");
master.run();

執(zhí)行node cluster.js 查看結果

在我的電腦上顯示結果為10724ms(電腦配置不同也會有差異)。