多執行緒/多行程在 Node.js 的使用時機

前言

最近在研究如何讓 Node.js 的程式可以同時接受大量的 Request ，
因為 Node.js 是單執行緖，想要達到目的，大約幾種方式，
1.) 增加 Thread 的數量
2.) 增加 Process 的數量
3.) 減少 Request 處理時間
減少 Request 處理時間可透過重構，調整程式 Logic 等方式，
接下來就 增加 Thread or Process 的方式及適用情況來說明

以下依 How To Use Multithreading in Node.js 及 How, in general, does Node.js handle 10,000 concurrent requests? 內容來分享

測試

1.) 增加 Thread 的數量
來自 How To Use Multithreading in Node.js 說明，
一個 Node.js Process 包含 7 條 Thread，1 條 Main Thread， 4 條 Node.js Thread 及 2 條 V8 Thread
4 條 Node.js Thread 就是來幫忙處理 I/O 操作，讓它不會 Block 住 main thread，
所以針對 I/O 操作幾乎不需要自已建立 Thread 來處理，有時自已建立 Thread 來處理 I/O 操作還可能會有效能問題。
那什麼狀況下，需要增加 Thread 來處理呢?
如果是 CPU-bound 的工作，就可以透過增加的 Thread 來處理，以避免 Block 住 Main Thread
以下建立程式來試試看，

mkdir multi-threading
cd multi-threading
npm init -y
npm install express

新增 index.js 來測試 CPU-bound 工作會 Block 住 Main thread

const express = require("express");
const app = express();
const port = process.env.PORT || 3000;
//the task itself of reading a file or a network request happens in parallel with the help of the threads
app.get("/non-blocking/", (req, res) => {
  res.status(200).send("this page is non-blocking");
});

app.get("/blocking", async (req, res) => {
  // let counter = 0;
  // for(let i =0;i<20_000_000_000;i++){
  //     counter++;
  // }
  const counter = await calculateCounter();
  res.status(200).send(`result is ${counter}`);
});

function calculateCounter() {
  return new Promise((resolve, reject) => {
    let counter = 0;
    for (let i = 0; i < 20_000_000_000; i++) {
      counter++;
    }
    resolve(counter);
  });
}

app.listen(port, () => {
  console.log(`App listening on port:${port}`);
});

程式中，在 const counter = await calculateCounter() 已使用了 async/await ，
它還是會 Block 住其他的 Request ，
執行 node index.js
使用 Browser 連到 http://localhost:3000/blocking 後，
開啟另一個 Browser 連到 http://localhost:3000/non-blocking，
該網頁要等 /blocking 處理完後，才會呈現出來。

所以 CPU-bound 的工作，使用 async/await 並無法讓它 non-blocking ，
這時就可以透過 Node.js 的 worker-threads 模組來將 CPU-bound 的工作放到額外的 Thread 中執行，讓它變成 non-blocking
因為建立Worker要傳入 js 檔案，所以新增worker.js，裡面是 CPU-bound 的工作

const { parentPort } = require("worker_threads");

let counter = 0;
for (let i = 0; i < 20_000_000_000; i++) {
  counter++;
}

parentPort.postMessage(counter);

將執行後的結果，透過parentPort.postMessage傳回給 Parent Thread，
新增 index2.js 透過 Worker 來建立額外的 Thread ，
並透過 worker.on('Event', fun) 來取得資料

const express = require("express");
const { Worker } = require("worker_threads");

const app = express();
const port = process.env.PORT || 3000;

app.get("/non-blocking/", (req, res) => {
  res.status(200).send("this page is non-blocking");
});

app.get("/blocking", async (req, res) => {
  const worker = new Worker("./worker.js");
  worker.on("message", (data) => {
    res.status(200).send(`result is ${data}`);
  });
  worker.on("error", (msg) => {
    res.status(404).send(`An error occurred:${msg}`);
  });
});

app.listen(port, () => {
  console.log(`App listening on port ${port}`);
});

執行 node index2.js
使用 Browser 連到 http://localhost:3000/blocking 後，
開啟另一個 Browser 連到 http://localhost:3000/non-blocking，
該網頁會馬上呈現，並不會被 /blocking Block 住。

那如果一個 CPU-bound 的工作執行太久，則可以想辦法將它們拆分成不同個工作，
然後建立多個 Worker 來處理，
就像 How To Use Multithreading in Node.js 最後的範例，
建立 4 個 Worker 並將回傳的 Promise 放到 Array 之中，最後透過 Promise.all 等它們執行完畢。

2.) 增加 Process 的數量
如果已將 CPU-bound 工作放到額外的 Thread 執行，效能還是有問題，
則可以透過 Cluster 來增加 Process 處理大量的 Request
建立 index4.js ，在 /blocking 中還是執行 CPU-bound 工作，
最後透過 cluster.fork 建立多個 Process，

const express = require("express");
const cluster = require("cluster");
const app = express();
const port = process.env.PORT || 3000;
let globalVar = 1;
let globalVarB = 1;
//the task itself of reading a file or a network request happens in parallel with the help of the threads
app.get("/non-blocking/", (req, res) => {
  globalVarB++;
  res
    .status(200)
    .send(
      `this page is non-blocking,Worker ${process.pid},globalVarB: ${globalVarB}`
    );
});

app.get("/blocking", async (req, res) => {
  let counter = 0;
  for (let i = 0; i < 20_000_000_000; i++) {
    counter++;
  }
  globalVar++;
  //const counter = await calculateCounter();
  res
    .status(200)
    .send(`Worker ${process.pid},globalVar: ${globalVar},result is ${counter}`);
});

function calculateCounter() {
  return new Promise((resolve, reject) => {
    let counter = 0;
    for (let i = 0; i < 20_000_000_000; i++) {
      counter++;
    }
    resolve(counter);
  });
}
// app.listen(port, ()=>{
//     console.log(`App listening on port:${port}`);
// });

// Check the number of available CPU.
const numCPUs = require("os").cpus().length;
// For Master process
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  // This event is firs when worker died
  cluster.on("exit", (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`);
  });
}
// For Worker
else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  app.listen(port, (err) => {
    err
      ? console.log("Error in server setup")
      : console.log(`Worker ${process.pid} started`);
  });
}

執行 node index4.js
如果開啟 Browser 連到 http://localhost:3000/blocking 或是 http://localhost:3000/non-blocking ，
可以發現有時會被 Block 住，有時又不會，
當執行在同一個 Process 中，就會被 Block，不同就不會 Block 到。
另外要注意的是，因為是不同的 Process ，所以是不同的 Memory ，
可以發現 globalVar 及 globalVarB 在不同的 Process 是不會影響到的。

3.) iisNode 的設定
iisNode 並不 Support Cluster ，如果要多個 Node.js Process ，
則可以透過設定 nodeProcessCountPerApplication 的值(預設是 1)
詳細可以參考 iisnode.yml

參考資源

How To Use Multithreading in Node.js
How, in general, does Node.js handle 10,000 concurrent requests?
Optimizing your Node.js app’s performance with clustering