亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Node.js中的多進程和多線程實例分析

發布時間:2022-07-26 09:37:28 來源:億速云 閱讀:168 作者:iii 欄目:web開發

本篇內容主要講解“Node.js中的多進程和多線程實例分析”,感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷,實用性強。下面就讓小編來帶大家學習“Node.js中的多進程和多線程實例分析”吧!

Node.js中的多進程和多線程實例分析

我們都知道 Node.js 采用的是單線程、基于事件驅動的異步 I/O 模型,其特性決定了它無法利用 CPU 多核的優勢,也不善于完成一些非 I/O 類型的操作(比如執行腳本、AI 計算、圖像處理等),為了解決此類問題,Node.js 提供了常規的多進(線程)方案。

child_process

我們可使用 child_process 模塊創建 Node.js 的子進程,來完成一些特殊的任務(比如執行腳本),該模塊主要提供了 execexecFileforkspwan 等方法,下面我們就簡單介紹下這些方法的使用。

exec

const { exec } = require('child_process');

exec('ls -al', (error, stdout, stderr) => {
  console.log(stdout);
});

該方法根據 options.shell 指定的可執行文件處理命令字符串,在命令的執行過程中緩存其輸出,直到命令執行完成后,再將執行結果以回調函數參數的形式返回。

該方法的參數解釋如下:

  • command:將要執行的命令(比如 ls -al);

  • options:參數設置(可不指定),相關屬性如下:

    • cwd:子進程的當前工作目錄,默認取 process.cwd() 的值;

    • env:環境變量設置(為鍵值對對象),默認取 process.env 的值;

    • encoding:字符編碼,默認值為:utf8

    • shell:處理命令字符串的可執行文件,Unix 上默認值為 /bin/shWindows 上默認值取 process.env.ComSpec 的值(如為空則為 cmd.exe);比如:

      const { exec } = require('child_process');
      
      exec("print('Hello World!')", { shell: 'python' }, (error, stdout, stderr) => {
        console.log(stdout);
      });

      運行上面的例子將輸出 Hello World!,這等同于子進程執行了 python -c "print('Hello World!')" 命令,因此在使用該屬性時需要注意,所指定的可執行文件必須支持通過 -c 選項來執行相關語句。

      注:碰巧 Node.js 也支持 -c 選項,但它等同于 --check 選項,只用來檢測指定的腳本是否存在語法錯誤,并不會執行相關腳本。

    • signal:使用指定的 AbortSignal 終止子進程,該屬性在 v14.17.0 以上可用,比如:

      const { exec } = require('child_process');
      
      const ac = new AbortController();
      exec('ls -al', { signal: ac.signal }, (error, stdout, stderr) => {});

      上例中,我們可通過調用 ac.abort() 來提前終止子進程。

    • timeout:子進程的超時時間(如果該屬性的值大于 0,那么當子進程運行時間超過指定值時,將會給子進程發送屬性 killSignal 指定的終止信號),單位毫米,默認值為 0

    • maxBuffer:stdout 或 stderr 所允許的最大緩存(二進制),如果超出,子進程將會被殺死,并且將會截斷任何輸出,默認值為 1024 * 1024

    • killSignal:子進程終止信號,默認值為 SIGTERM

    • uid:執行子進程的 uid

    • gid:執行子進程的 gid

    • windowsHide:是否隱藏子進程的控制臺窗口,常用于 Windows 系統,默認值為 false

  • callback:回調函數,包含 errorstdoutstderr 三個參數:

    • error:如果命令行執行成功,值為 null,否則值為 Error 的一個實例,其中 error.code 為子進程的退出的錯誤碼,error.signal 為子進程終止的信號;

    • stdoutstderr:子進程的 stdoutstderr,按照 encoding 屬性的值進行編碼,如果 encoding 的值為 buffer,或者 stdoutstderr 的值是一個無法識別的字符串,將按照 buffer 進行編碼。

execFile

const { execFile } = require('child_process');

execFile('ls', ['-al'], (error, stdout, stderr) => {
  console.log(stdout);
});

該方法的功能類似于 exec,唯一的區別是 execFile 在默認情況下直接用指定的可執行文件(即參數 file 的值)處理命令,這使得其效率略高于 exec(如果查看 shell 的處理邏輯,筆者感覺這效率可忽略不計)。

該方法的參數解釋如下:

  • file:可執行文件的名字或路徑;

  • args:可執行文件的參數列表;

  • options:參數設置(可不指定),相關屬性如下:

    • shell:值為 false 時表示直接用指定的可執行文件(即參數 file 的值)處理命令,值為 true 或其它字符串時,作用等同于 exec 中的 shell,默認值為 false

    • windowsVerbatimArguments:在 Windows 中是否對參數進行引號或轉義處理,在 Unix 中將忽略該屬性,默認值為 false

    • 屬性 cwdenvencodingtimeoutmaxBufferkillSignaluidgidwindowsHidesignal 在上文中已介紹,此處不再重述。

  • callback:回調函數,等同于 exec 中的 callback,此處不再闡述。

fork

const { fork } = require('child_process');

const echo = fork('./echo.js', {
  silent: true
});
echo.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

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

echo.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

該方法用于創建新的 Node.js 實例以執行指定的 Node.js 腳本,與父進程之間以 IPC 方式進行通信。

該方法的參數解釋如下:

  • modulePath:要運行的 Node.js 腳本路徑;

  • args:傳遞給 Node.js 腳本的參數列表;

  • options:參數設置(可不指定),相關屬性如:

    • 如果指定了該屬性,將忽略 slient 的值;

    • 必須包含一個值為 ipc 的選項(比如 [0, 1, 2, 'ipc']),否則將拋出異常。

    • detached:參見下文對 spwanoptions.detached 的說明;

    • execPath:創建子進程的可執行文件;

    • execArgv:傳遞給可執行文件的字符串參數列表,默認取 process.execArgv 的值;

    • serialization:進程間消息的序列號類型,可用值為 jsonadvanced,默認值為 json

    • slient: 如果為 true,子進程的 stdinstdoutstderr 將通過管道傳遞給父進程,否則將繼承父進程的 stdinstdoutstderr;默認值為 false

    • stdio:參見下文對 spwanoptions.stdio 的說明。這里需要注意的是:

    • 屬性 cwdenvuidgidwindowsVerbatimArgumentssignaltimeoutkillSignal 在上文中已介紹,此處不再重述。

spwan

const { spawn } = require('child_process');

const ls = spawn('ls', ['-al']);
ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

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

ls.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

該方法為 child_process 模塊的基礎方法,execexecFilefork 最終都會調用 spawn 來創建子進程。

該方法的參數解釋如下:

  • command:可執行文件的名字或路徑;

  • args:傳遞給可執行文件的參數列表;

  • options:參數設置(可不指定),相關屬性如下:

    • 值為字符串時,會將其轉換為含有三個項的數組(比如 pipe 被轉換為 ['pipe', 'pipe', 'pipe']),可用值為 pipeoverlappedignoreinherit

    • 值為數組時,其中數組的前三項分別代表對 stdinstdoutstderr 的配置,每一項的可用值為 pipeoverlappedignoreinheritipc、Stream 對象、正整數(在父進程打開的文件描述符)、null(如位于數組的前三項,等同于 pipe,否則等同于 ignore)、undefined(如位于數組的前三項,等同于 pipe,否則等同于 ignore)。

    • Windows 系統中,父進程退出后,子進程可以繼續運行,并且子進程擁有自己的控制臺窗口(該特性一旦啟動后,在運行過程中將無法更改);

    • 在非 Windows 系統中,子進程將作為新進程會話組的組長,此刻不管子進程是否與父進程分離,子進程都可以在父進程退出后繼續運行。

    • 調用子進程的 unref 方法從而將子進程從父進程的事件循環中剔除;

    • detached 設置為 true

    • stdioignore

    • argv0:發送給子進程 argv[0] 的值,默認取參數 command 的值;

    • detached:是否允許子進程可以獨立于父進程運行(即父進程退出后,子進程可以繼續運行),默認值為 false,其值為 true 時,各平臺的效果如下所述:

      需要注意的是,如果子進程需要執行長時間的任務,并且想要父進程提前退出,需要同時滿足以下幾點:

      比如下面的例子:

      // hello.js
      const fs = require('fs');
      let index = 0;
      function run() {
        setTimeout(() => {
          fs.writeFileSync('./hello', `index: ${index}`);
          if (index < 10) {
            index += 1;
            run();
          }
        }, 1000);
      }
      run();
      
      // main.js
      const { spawn } = require('child_process');
      const child = spawn('node', ['./hello.js'], {
        detached: true,
        stdio: 'ignore'
      });
      child.unref();
    • stdio:子進程標準輸入輸出配置,默認值為 pipe,值為字符串或數組:

    • 屬性 cwdenvuidgidserializationshell(值為 booleanstring)、windowsVerbatimArgumentswindowsHidesignaltimeoutkillSignal 在上文中已介紹,此處不再重述。

小結

上文對 child_process 模塊中主要方法的使用進行了簡短介紹,由于 execSyncexecFileSyncforkSyncspwanSync 方法是 execexecFilespwan 的同步版本,其參數并無任何差異,故不再重述。

cluster

通過 cluster 模塊我們可以創建 Node.js 進程集群,通過 Node.js 進程進群,我們可以更加充分地利用多核的優勢,將程序任務分發到不同的進程中以提高程序的執行效率;下面將通過例子為大家介紹 cluster 模塊的使用:

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

if (cluster.isPrimary) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`${process.pid}\n`);
  }).listen(8000);
}

上例通過 cluster.isPrimary 屬性判斷(即判斷當前進程是否為主進程)將其分為兩個部分:

  • 為真時,根據 CPU 內核的數量并通過 cluster.fork 調用來創建相應數量的子進程;

  • 為假時,創建一個 HTTP server,并且每個 HTTP server 都監聽同一個端口(此處為 8000)。

運行上面的例子,并在瀏覽器中訪問 http://localhost:8000/,我們會發現每次訪問返回的 pid 都不一樣,這說明了請求確實被分發到了各個子進程。Node.js 默認采用的負載均衡策略是輪詢調度,可通過環境變量 NODE_CLUSTER_SCHED_POLICYcluster.schedulingPolicy 屬性來修改其負載均衡策略:

NODE_CLUSTER_SCHED_POLICY = rr // 或 none

cluster.schedulingPolicy = cluster.SCHED_RR; // 或 cluster.SCHED_NONE

另外需要注意的是,雖然每個子進程都創建了 HTTP server,并都監聽了同一個端口,但并不代表由這些子進程自由競爭用戶請求,因為這樣無法保證所有子進程的負載達到均衡。所以正確的流程應該是由主進程監聽端口,然后將用戶請求根據分發策略轉發到具體的子進程進行處理。

由于進程之間是相互隔離的,因此進程之間一般通過共享內存、消息傳遞、管道等機制進行通訊。Node.js 則是通過消息傳遞來完成父子進程之間的通信,比如下面的例子:

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

if (cluster.isPrimary) {
  for (let i = 0; i < numCPUs; i++) {
    const worker = cluster.fork();
    worker.on('message', (message) => {
      console.log(`I am primary(${process.pid}), I got message from worker: "${message}"`);
      worker.send(`Send message to worker`)
    });
  }
} else {
  process.on('message', (message) => {
    console.log(`I am worker(${process.pid}), I got message from primary: "${message}"`)
  });
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`${process.pid}\n`);
    process.send('Send message to primary');
  }).listen(8000);
}

運行上面的例子,并訪問 http://localhost:8000/,再查看終端,我們會看到類似下面的輸出:

I am primary(44460), I got message from worker: "Send message to primary"
I am worker(44461), I got message from primary: "Send message to worker"
I am primary(44460), I got message from worker: "Send message to primary"
I am worker(44462), I got message from primary: "Send message to worker"

利用該機制,我們可以監聽各子進程的狀態,以便在某個子進程出現意外后,能夠及時對其進行干預,以保證服務的可用性。

cluster 模塊的接口非常簡單,為了節省篇幅,這里只對 cluster.setupPrimary 方法做一些特別聲明,其它方法請查看官方文檔:

  • cluster.setupPrimary 調用后,相關設置將同步到在 cluster.settings 屬性中,并且每次調用都基于當前 cluster.settings 屬性的值;

  • cluster.setupPrimary 調用后,對已運行的子進程沒有影響,只影響后續的 cluster.fork 調用;

  • cluster.setupPrimary 調用后,不影響后續傳遞給 cluster.fork 調用的 env 參數;

  • cluster.setupPrimary 只能在主進程中使用。

worker_threads

前文我們對 cluster 模塊進行了介紹,通過它我們可以創建 Node.js 進程集群以提高程序的運行效率,但 cluster 基于多進程模型,進程間高成本的切換以及進程間資源的隔離,會隨著子進程數量的增加,很容易導致因系統資源緊張而無法響應的問題。為解決此類問題,Node.js 提供了 worker_threads,下面我們通過具體的例子對該模塊的使用進行簡單介紹:

// server.js
const http = require('http');
const { Worker } = require('worker_threads');

http.createServer((req, res) => {
  const httpWorker = new Worker('./http_worker.js');
  httpWorker.on('message', (result) => {
    res.writeHead(200);
    res.end(`${result}\n`);
  });
  httpWorker.postMessage('Tom');
}).listen(8000);

// http_worker.js
const { parentPort } = require('worker_threads');

parentPort.on('message', (name) => {
  parentPort.postMessage(`Welcone ${name}!`);
});

上例展示了 worker_threads 的簡單使用,在使用 worker_threads 的過程中,需要注意以下幾點:

  • 通過 worker_threads.Worker 創建 Worker 實例,其中 Worker 腳本既可以為一個獨立的 JavaScript 文件,也可以為字符串,比如上例可修改為:

    const code = "const { parentPort } = require('worker_threads'); parentPort.on('message', (name) => {parentPort.postMessage(`Welcone ${name}!`);})";
    const httpWorker = new Worker(code, { eval: true });
  • 通過 worker_threads.Worker 創建 Worker 實例時,可以通過指定 workerData 的值來設置 Worker 子線程的初始元數據,比如:

    // server.js
    const { Worker } = require('worker_threads');
    const httpWorker = new Worker('./http_worker.js', { workerData: { name: 'Tom'} });
    
    // http_worker.js
    const { workerData } = require('worker_threads');
    console.log(workerData);
  • 通過 worker_threads.Worker 創建 Worker 實例時,可通過設置 SHARE_ENV 以實現在 Worker 子線程與主線程之間共享環境變量的需求,比如:

    const { Worker, SHARE_ENV } = require('worker_threads');
    const worker = new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV });
    worker.on('exit', () => {
      console.log(process.env.SET_IN_WORKER);
    });
  • 不同于 cluster 中進程間的通信機制,worker_threads 采用的 MessageChannel 來進行線程間的通信:

    • Worker 子線程通過 parentPort.postMessage 方法發送消息給主線程,并通過監聽 parentPortmessage 事件來處理來自主線程的消息;

    • 主線程通過 Worker 子線程實例(此處為 httpWorker,以下均以此代替 Worker 子線程)的 postMessage 方法發送消息給 httpWorker,并通過監聽 httpWorkermessage 事件來處理來自 Worker 子線程的消息。

在 Node.js 中,無論是 cluster 創建的子進程,還是 worker_threads 創建的 Worker 子線程,它們都擁有屬于自己的 V8 實例以及事件循環,所不同的是:

  • 子進程之間的內存空間是互相隔離的,而 Worker 子線程共享所屬進程的內存空間;

  • 子進程之間的切換成本要遠遠高于 Worker 子線程之間的切換成本。

盡管看起來 Worker 子線程比子進程更高效,但 Worker 子線程也有不足的地方,即cluster 提供了負載均衡,而 worker_threads 則需要我們自行完成負載均衡的設計與實現。

到此,相信大家對“Node.js中的多進程和多線程實例分析”有了更深的了解,不妨來實際操作一番吧!這里是億速云網站,更多相關內容可以進入相關頻道進行查詢,關注我們,繼續學習!

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

荥阳市| 泗阳县| 平安县| 陵川县| 连南| 宝兴县| 淮滨县| 合江县| 新化县| 六安市| 平泉县| 莱州市| 兴海县| 敖汉旗| 柘城县| 册亨县| 盐池县| 和林格尔县| 龙游县| 当雄县| 无极县| 大名县| 金山区| 北宁市| 怀宁县| 龙江县| 白山市| 温泉县| 桂东县| 莱西市| 河东区| 英德市| 靖宇县| 东方市| 翁源县| 黄骅市| 乐至县| 达尔| 将乐县| 丰宁| 潞城市|