深入理解Node.js 程式與執行緒(8000長文徹底搞懂)

前言

程式與執行緒是一個程式設計師的必知概念，面試經常被問及，但是一些文章內容只是講講理論知識，可能一些小夥伴並沒有真的理解，在實際開發中應用也比較少。本篇文章除了介紹概念，通過Node.js 的角度講解程式與執行緒，並且講解一些在專案中的實戰的應用，讓你不僅能迎戰面試官還可以在實戰中完美應用。

文章導覽

面試會問

Node.js是單執行緒嗎？

Node.js 做耗時的計算時候，如何避免阻塞？

Node.js如何實現多程式的開啟和關閉？

Node.js可以建立執行緒嗎？

你們開發過程中如何實現程式守護的？

除了使用第三方模組，你們自己是否封裝過一個多程式架構?

程式

程式Process是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎，程式是執行緒的容器（來自百科）。程式是資源分配的最小單位。我們啟動一個服務、執行一個例項，就是開一個服務程式，例如 Java 裡的 JVM 本身就是一個程式，Node.js 裡通過 node app.js 開啟一個服務程式，多程式就是程式的複製（fork），fork 出來的每個程式都擁有自己的獨立空間地址、資料棧，一個程式無法訪問另外一個程式裡定義的變數、資料結構，只有建立了 IPC 通訊，程式之間才可資料共享。

• Node.js開啟服務程式例子

const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程式設計師成長指北測試程式';
    console.log('程式id',process.pid)
})

執行上面程式碼後，以下為 Mac 系統自帶的監控工具 “活動監視器” 所展示的效果，可以看到我們剛開啟的 Nodejs 程式 7663

執行緒

執行緒是作業系統能夠進行運算排程的最小單位，首先我們要清楚執行緒是隸屬於程式的，被包含於程式之中。一個執行緒只能隸屬於一個程式，但是一個程式是可以擁有多個執行緒的。

單執行緒

單執行緒就是一個程式只開一個執行緒

Javascript 就是屬於單執行緒，程式順序執行(這裡暫且不提JS非同步)，可以想象一下佇列，前面一個執行完之後，後面才可以執行，當你在使用單執行緒語言編碼時切勿有過多耗時的同步操作，否則執行緒會造成阻塞，導致後續響應無法處理。你如果採用 Javascript 進行編碼時候，請儘可能的利用Javascript非同步操作的特性。

經典計算耗時造成執行緒阻塞的例子

const http = require('http');
const longComputation = () => {
  let sum = 0;
  for (let i = 0; i < 1e10; i++) {
    sum += i;
  };
  return sum;
};
const server = http.createServer();
server.on('request', (req, res) => {
  if (req.url === '/compute') {
    console.info('計算開始',new Date());
    const sum = longComputation();
    console.info('計算結束',new Date());
    return res.end(`Sum is ${sum}`);
  } else {
    res.end('Ok')
  }
});

server.listen(3000);
//列印結果
//計算開始 2019-07-28T07:08:49.849Z
//計算結束 2019-07-28T07:09:04.522Z

檢視列印結果，當我們呼叫127.0.0.1:3000/compute
的時候，如果想要呼叫其他的路由地址比如127.0.0.1/大約需要15秒時間，也可以說一個使用者請求完第一個compute介面後需要等待15秒，這對於使用者來說是極其不友好的。下文我會通過建立多程式的方式child_process.fork 和cluster 來解決解決這個問題。

單執行緒的一些說明

• Node.js 雖然是單執行緒模型，但是其基於事件驅動、非同步非阻塞模式，可以應用於高併發場景，避免了執行緒建立、執行緒之間上下文切換所產生的資源開銷。
• 當你的專案中需要有大量計算，CPU 耗時的操作時候，要注意考慮開啟多程式來完成了。
• Node.js 開發過程中，錯誤會引起整個應用退出，應用的健壯性值得考驗，尤其是錯誤的異常丟擲，以及程式守護是必須要做的。
• 單執行緒無法利用多核CPU，但是後來Node.js 提供的API以及一些第三方工具相應都得到了解決，文章後面都會講到。

Node.js 中的程式與執行緒

Node.js 是 Javascript 在服務端的執行環境，構建在 chrome 的 V8 引擎之上，基於事件驅動、非阻塞I/O模型，充分利用作業系統提供的非同步 I/O 進行多工的執行，適合於 I/O 密集型的應用場景，因為非同步，程式無需阻塞等待結果返回，而是基於回撥通知的機制，原本同步模式等待的時間，則可以用來處理其它任務，

科普：在 Web 伺服器方面，著名的 Nginx 也是採用此模式（事件驅動），避免了多執行緒的執行緒建立、執行緒上下文切換的開銷，Nginx 採用 C 語言進行編寫，主要用來做高效能的 Web 伺服器，不適合做業務。

Web業務開發中，如果你有高併發應用場景那麼 Node.js 會是你不錯的選擇。

在單核 CPU 系統之上我們採用 單程式 + 單執行緒 的模式來開發。在多核 CPU 系統之上，可以通過 child_process.fork 開啟多個程式（Node.js 在 v0.8 版本之後新增了Cluster 來實現多程式架構） ，即 多程式 + 單執行緒 模式。注意：開啟多程式不是為了解決高併發，主要是解決了單程式模式下 Node.js CPU 利用率不足的情況，充分利用多核 CPU 的效能。

Node.js 中的程式

process 模組

Node.js 中的程式 Process 是一個全域性物件，無需 require 直接使用，給我們提供了當前程式中的相關資訊。官方文件提供了詳細的說明，感興趣的可以親自實踐下 Process 文件。

• process.env：環境變數，例如通過 process.env.NODE_ENV 獲取不同環境專案配置資訊
• process.nextTick：這個在談及 Event Loop 時經常為會提到
• process.pid：獲取當前程式id
• process.ppid：當前程式對應的父程式
• process.cwd()：獲取當前程式工作目錄，
• process.platform：獲取當前程式執行的作業系統平臺
• process.uptime()：當前程式已執行時間，例如：pm2 守護程式的 uptime 值
• 程式事件：process.on(‘uncaughtException’, cb) 捕獲異常資訊、process.on(‘exit’, cb）程式推出監聽
• 三個標準流：process.stdout 標準輸出、process.stdin 標準輸入、process.stderr 標準錯誤輸出
• process.title 指定程式名稱，有的時候需要給程式指定一個名稱

以上僅列舉了部分常用到功能點，除了 Process 之外 Node.js 還提供了 child_process 模組用來對子程式進行操作，在下文 Nodejs程式建立會繼續講述。

Node.js 程式建立

程式建立有多種方式，本篇文章以child_process模組和cluster模組進行講解。

child_process模組

child_process 是 Node.js 的內建模組，官網地址：

child_process 官網地址：http://nodejs.cn/api/child_pr...

幾個常用函式：
四種方式

• child_process.spawn()：適用於返回大量資料，例如影象處理，二進位制資料處理。
• child_process.exec()：適用於小量資料，maxBuffer 預設值為 200 * 1024 超出這個預設值將會導致程式崩潰，資料量過大可採用 spawn。
• child_process.execFile()：類似 child_process.exec()，區別是不能通過 shell 來執行，不支援像 I/O 重定向和檔案查詢這樣的行為
• child_process.fork()： 衍生新的程式，程式之間是相互獨立的，每個程式都有自己的 V8 例項、記憶體，系統資源是有限的，不建議衍生太多的子程式出來，通長根據系統 CPU 核心數設定。

CPU 核心數這裡特別說明下，fork 確實可以開啟多個程式，但是並不建議衍生出來太多的程式，cpu核心數的獲取方式const cpus = require('os').cpus();,這裡 cpus 返回一個物件陣列，包含所安裝的每個 CPU/核心的資訊，二者總和的陣列哦。假設主機裝有兩個cpu，每個cpu有4個核，那麼總核數就是8。

fork開啟子程式 Demo

fork開啟子程式解決文章起初的計算耗時造成執行緒阻塞。
在進行 compute 計算時建立子程式，子程式計算完成通過 send 方法將結果傳送給主程式，主程式通過 message 監聽到資訊後處理並退出。

fork_app.js

const http = require('http');
const fork = require('child_process').fork;

const server = http.createServer((req, res) => {
    if(req.url == '/compute'){
        const compute = fork('./fork_compute.js');
        compute.send('開啟一個新的子程式');

        // 當一個子程式使用 process.send() 傳送訊息時會觸發 'message' 事件
        compute.on('message', sum => {
            res.end(`Sum is ${sum}`);
            compute.kill();
        });

        // 子程式監聽到一些錯誤訊息退出
        compute.on('close', (code, signal) => {
            console.log(`收到close事件，子程式收到訊號 ${signal} 而終止，退出碼 ${code}`);
            compute.kill();
        })
    }else{
        res.end(`ok`);
    }
});
server.listen(3000, 127.0.0.1, () => {
    console.log(`server started at http://${127.0.0.1}:${3000}`);
});

fork_compute.js

針對文初需要進行計算的的例子我們建立子程式拆分出來單獨進行運算。

const computation = () => {
    let sum = 0;
    console.info('計算開始');
    console.time('計算耗時');

    for (let i = 0; i < 1e10; i++) {
        sum += i
    };

    console.info('計算結束');
    console.timeEnd('計算耗時');
    return sum;
};

process.on('message', msg => {
    console.log(msg, 'process.pid', process.pid); // 子程式id
    const sum = computation();

    // 如果Node.js程式是通過程式間通訊產生的，那麼，process.send()方法可以用來給父程式傳送訊息
    process.send(sum);
})

cluster模組

cluster 開啟子程式Demo

const http = require('http');
const numCPUs = require('os').cpus().length;
const cluster = require('cluster');
if(cluster.isMaster){
    console.log('Master proces id is',process.pid);
    // fork workers
    for(let i= 0;i<numCPUs;i++){
        cluster.fork();
    }
    cluster.on('exit',function(worker,code,signal){
        console.log('worker process died,id',worker.process.pid)
    })
}else{
    // Worker可以共享同一個TCP連線
    // 這裡是一個http伺服器
    http.createServer(function(req,res){
        res.writeHead(200);
        res.end('hello word');
    }).listen(8000);

}

cluster原理分析

cluster模組呼叫fork方法來建立子程式，該方法與child_process中的fork是同一個方法。
cluster模組採用的是經典的主從模型，Cluster會建立一個master，然後根據你指定的數量複製出多個子程式，可以使用cluster.isMaster屬性判斷當前程式是master還是worker(工作程式)。由master程式來管理所有的子程式，主程式不負責具體的任務處理，主要工作是負責排程和管理。

cluster模組使用內建的負載均衡來更好地處理執行緒之間的壓力，該負載均衡使用了Round-robin演算法（也被稱之為迴圈演算法）。當使用Round-robin排程策略時，master accepts()所有傳入的連線請求，然後將相應的TCP請求處理髮送給選中的工作程式（該方式仍然通過IPC來進行通訊）。

開啟多程式時候埠疑問講解：如果多個Node程式監聽同一個埠時會出現 Error:listen EADDRIUNS的錯誤，而cluster模組為什麼可以讓多個子程式監聽同一個埠呢?原因是master程式內部啟動了一個TCP伺服器，而真正監聽埠的只有這個伺服器，當來自前端的請求觸發伺服器的connection事件後，master會將對應的socket具柄傳送給子程式。

child_process 模組與cluster 模組總結

無論是 child_process 模組還是 cluster 模組，為了解決 Node.js 例項單執行緒執行，無法利用多核 CPU 的問題而出現的。核心就是父程式（即 master 程式）負責監聽埠，接收到新的請求後將其分發給下面的 worker 程式。

cluster模組的一個弊端：

cluster內部隱時的構建TCP伺服器的方式來說對使用者確實簡單和透明瞭很多，但是這種方式無法像使用child_process那樣靈活，因為一直主程式只能管理一組相同的工作程式，而自行通過child_process來建立工作程式，一個主程式可以控制多組程式。原因是child_process操作子程式時，可以隱式的建立多個TCP伺服器，對比上面的兩幅圖應該能理解我說的內容。

Node.js程式通訊原理

前面講解的無論是child_process模組，還是cluster模組，都需要主程式和工作程式之間的通訊。通過fork()或者其他API，建立了子程式之後，為了實現父子程式之間的通訊，父子程式之間才能通過message和send()傳遞資訊。

IPC這個詞我想大家並不陌生，不管那一張開發語言只要提到程式通訊，都會提到它。IPC的全稱是Inter-Process Communication,即程式間通訊。它的目的是為了讓不同的程式能夠互相訪問資源並進行協調工作。實現程式間通訊的技術有很多，如命名管道，匿名管道，socket，訊號量，共享記憶體，訊息佇列等。Node中實現IPC通道是依賴於libuv。windows下由命名管道(name pipe)實現，*nix系統則採用Unix Domain Socket實現。表現在應用層上的程式間通訊只有簡單的message事件和send()方法，介面十分簡潔和訊息化。

IPC建立和實現示意圖

IPC通訊管道是如何建立的

父程式在實際建立子程式之前，會建立IPC通道並監聽它，然後才真正的建立出子程式，這個過程中也會通過環境變數（NODE_CHANNEL_FD）告訴子程式這個IPC通道的檔案描述符。子程式在啟動的過程中，根據檔案描述符去連線這個已存在的IPC通道，從而完成父子程式之間的連線。

Node.js控制程式碼傳遞

講控制程式碼之前，先想一個問題，send控制程式碼傳送的時候，真的是將伺服器物件傳送給了子程式？

子程式物件send()方法可以傳送的控制程式碼型別

• net.Socket TCP套接字
• net.Server TCP伺服器，任意建立在TCP服務上的應用層服務都可以享受它帶來的好處
• net.Native C++層面的TCP套接字或IPC管道
• dgram.Socket UDP套接字
• dgram.Native C++層面的UDP套接字

send控制程式碼傳送原理分析

結合控制程式碼的傳送與還原示意圖更容易理解。

send()方法在將訊息傳送到IPC管道前，實際將訊息組裝成了兩個物件，一個引數是hadler，另一個是message。message引數如下所示：

{
    cmd:'NODE_HANDLE',
    type:'net.Server',
    msg:message
}

傳送到IPC管道中的實際上是我們要傳送的控制程式碼檔案描述符。這個message物件在寫入到IPC管道時，也會通過JSON.stringfy()進行序列化。所以最終傳送到IPC通道中的資訊都是字串，send()方法能傳送訊息和控制程式碼並不意味著它能傳送任何物件。

連線了IPC通道的子執行緒可以讀取父程式發來的訊息，將字串通過JSON.parse()解析還原為物件後，才觸發message事件將訊息傳遞給應用層使用。在這個過程中，訊息物件還要被進行過濾處理，message.cmd的值如果以NODE_為字首，它將響應一個內部事件internalMessage，如果message.cmd值為NODE_HANDLE,它將取出message.type值和得到的檔案描述符一起還原出一個對應的物件。

以傳送的TCP伺服器控制程式碼為例，子程式收到訊息後的還原過程程式碼如下:

function(message,handle,emit){
    var self = this;
    
    var server = new net.Server();
    server.listen(handler,function(){
      emit(server);
    });
}

這段還原始碼，子程式根據message.type建立對應的TCP伺服器物件，然後監聽到檔案描述符上。由於底層細節不被應用層感知，所以子程式中，開發者會有一種伺服器物件就是從父程式中直接傳遞過來的錯覺。

Node程式之間只有訊息傳遞，不會真正的傳遞物件，這種錯覺是抽象封裝的結果。目前Node只支援我前面提到的幾種控制程式碼，並非任意型別的控制程式碼都能在程式之間傳遞，除非它有完整的傳送和還原的過程。

Node.js多程式架構模型

我們自己實現一個多程式架構守護Demo

編寫主程式

master.js 主要處理以下邏輯：

• 建立一個 server 並監聽 3000 埠。
• 根據系統 cpus 開啟多個子程式
• 通過子程式物件的 send 方法傳送訊息到子程式進行通訊
• 在主程式中監聽了子程式的變化，如果是自殺訊號重新啟動一個工作程式。
• 主程式在監聽到退出訊息的時候，先退出子程式在退出主程式

// master.js
const fork = require('child_process').fork;
const cpus = require('os').cpus();

const server = require('net').createServer();
server.listen(3000);
process.title = 'node-master'

const workers = {};
const createWorker = () => {
    const worker = fork('worker.js')
    worker.on('message', function (message) {
        if (message.act === 'suicide') {
            createWorker();
        }
    })
    worker.on('exit', function(code, signal) {
        console.log('worker process exited, code: %s signal: %s', code, signal);
        delete workers[worker.pid];
    });
    worker.send('server', server);
    workers[worker.pid] = worker;
    console.log('worker process created, pid: %s ppid: %s', worker.pid, process.pid);
}

for (let i=0; i<cpus.length; i++) {
    createWorker();
}

process.once('SIGINT', close.bind(this, 'SIGINT')); // kill(2) Ctrl-C
process.once('SIGQUIT', close.bind(this, 'SIGQUIT')); // kill(3) Ctrl-\
process.once('SIGTERM', close.bind(this, 'SIGTERM')); // kill(15) default
process.once('exit', close.bind(this));

function close (code) {
    console.log('程式退出！', code);

    if (code !== 0) {
        for (let pid in workers) {
            console.log('master process exited, kill worker pid: ', pid);
            workers[pid].kill('SIGINT');
        }
    }

    process.exit(0);
}

工作程式

worker.js 子程式處理邏輯如下：

• 建立一個 server 物件，注意這裡最開始並沒有監聽 3000 埠
• 通過 message 事件接收主程式 send 方法傳送的訊息
• 監聽 uncaughtException 事件，捕獲未處理的異常，傳送自殺資訊由主程式重建程式，子程式在連結關閉之後退出

// worker.js
const http = require('http');
const server = http.createServer((req, res) => {
    res.writeHead(200, {
        'Content-Type': 'text/plan'
    });
    res.end('I am worker, pid: ' + process.pid + ', ppid: ' + process.ppid);
    throw new Error('worker process exception!'); // 測試異常程式退出、重啟
});

let worker;
process.title = 'node-worker'
process.on('message', function (message, sendHandle) {
    if (message === 'server') {
        worker = sendHandle;
        worker.on('connection', function(socket) {
            server.emit('connection', socket);
        });
    }
});

process.on('uncaughtException', function (err) {
    console.log(err);
    process.send({act: 'suicide'});
    worker.close(function () {
        process.exit(1);
    })
})

Node.js 程式守護

什麼是程式守護？

每次啟動 Node.js 程式都需要在命令視窗輸入命令 node app.js 才能啟動，但如果把命令視窗關閉則Node.js 程式服務就會立刻斷掉。除此之外，當我們這個 Node.js 服務意外崩潰了就不能自動重啟程式了。這些現象都不是我們想要看到的，所以需要通過某些方式來守護這個開啟的程式，執行 node app.js 開啟一個服務程式之後，我還可以在這個終端上做些別的事情，且不會相互影響。，當出現問題可以自動重啟。

如何實現程式守護

這裡我只說一些第三方的程式守護框架，pm2 和 forever ，它們都可以實現程式守護，底層也都是通過上面講的 child_process 模組和 cluster 模組 實現的，這裡就不再提它們的原理。

pm2 指定生產環境啟動一個名為 test 的 node 服務

pm2 start app.js --env production --name test

pm2常用api

• pm2 stop Name/processID 停止某個服務，通過服務名稱或者服務程式ID
• pm2 delete Name/processID 刪除某個服務，通過服務名稱或者服務程式ID
• pm2 logs [Name] 檢視日誌，如果新增服務名稱，則指定檢視某個服務的日誌，不加則檢視所有日誌
• pm2 start app.js -i 4 叢集，-i <number of workers>引數用來告訴PM2以cluster_mode的形式執行你的app（對應的叫fork_mode），後面的數字表示要啟動的工作執行緒的數量。如果給定的數字為0，PM2則會根據你CPU核心的數量來生成對應的工作執行緒。注意一般在生產環境使用cluster_mode模式，測試或者本地環境一般使用fork模式，方便測試到錯誤。
• pm2 reload Name pm2 restart Name 應用程式程式碼有更新，可以用過載來載入新程式碼，也可以用重啟來完成,reload可以做到0秒當機載入新的程式碼，restart則是重新啟動，生產環境中多用reload來完成程式碼更新！
• pm2 show Name 檢視服務詳情
• pm2 list 檢視pm2中所有專案
• pm2 monit用monit可以開啟實時監視器去檢視資源佔用情況

pm2 官網地址：

http://pm2.keymetrics.io/docs...

forever 就不特殊說明了，官網地址

https://github.com/foreverjs/...

注意：二者更推薦pm2，看一下二者對比就知道我為什麼更推薦使用pm2了。https://www.jianshu.com/p/fdc...

linux 關閉一個程式

• 查詢與程式相關的PID號

  ps aux | grep server

說明:

    root     20158  0.0  5.0 1251592 95396 ?       Sl   5月17   1:19 node /srv/mini-program-api/launch_pm2.js

上面是執行命令後在linux中顯示的結果，第二個引數就是程式對應的PID

• 殺死程式

1. 以優雅的方式結束程式

   kill -l PID

   -l選項告訴kill命令用好像啟動程式的使用者已登出的方式結束程式。

當使用該選項時，kill命令也試圖殺死所留下的子程式。
但這個命令也不是總能成功--或許仍然需要先手工殺死子程式，然後再殺死父程式。

1. kill 命令用於終止程式

   例如： kill -9 [PID]

-9 表示強迫程式立即停止

這個強大和危險的命令迫使程式在執行時突然終止，程式在結束後不能自我清理。
危害是導致系統資源無法正常釋放，一般不推薦使用，除非其他辦法都無效。
當使用此命令時，一定要通過ps -ef確認沒有剩下任何殭屍程式。
只能通過終止父程式來消除殭屍程式。如果殭屍程式被init收養，問題就比較嚴重了。
殺死init程式意味著關閉系統。
如果系統中有殭屍程式，並且其父程式是init，
而且殭屍程式佔用了大量的系統資源，那麼就需要在某個時候重啟機器以清除程式表了。

1. killall命令

   殺死同一程式組內的所有程式。其允許指定要終止的程式的名稱，而非PID。

   killall httpd

Node.js 執行緒

Node.js關於單執行緒的誤區

const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程式設計師成長指北測試程式';
    console.log('程式id',process.pid)
})

仍然看本文第一段程式碼，建立了http服務，開啟了一個程式，都說了Node.js是單執行緒，所以 Node 啟動後執行緒數應該為 1，但是為什麼會開啟7個執行緒呢？難道Javascript不是單執行緒不知道小夥伴們有沒有這個疑問？

解釋一下這個原因：

Node 中最核心的是 v8 引擎，在 Node 啟動後，會建立 v8 的例項，這個例項是多執行緒的。

• 主執行緒：編譯、執行程式碼。
• 編譯/優化執行緒：在主執行緒執行的時候，可以優化程式碼。
• 分析器執行緒：記錄分析程式碼執行時間，為 Crankshaft 優化程式碼執行提供依據。
• 垃圾回收的幾個執行緒。

所以大家常說的 Node 是單執行緒的指的是 JavaScript 的執行是單執行緒的(開發者編寫的程式碼執行在單執行緒環境中)，但 Javascript 的宿主環境，無論是 Node 還是瀏覽器都是多執行緒的因為libuv中有執行緒池的概念存在的，libuv會通過類似執行緒池的實現來模擬不同作業系統的非同步呼叫，這對開發者來說是不可見的。

某些非同步 IO 會佔用額外的執行緒

還是上面那個例子，我們在定時器執行的同時，去讀一個檔案：

const fs = require('fs')
setInterval(() => {
    console.log(new Date().getTime())
}, 3000)

fs.readFile('./index.html', () => {})

執行緒數量變成了 11 個，這是因為在 Node 中有一些 IO 操作（DNS，FS）和一些 CPU 密集計算（Zlib，Crypto）會啟用 Node 的執行緒池，而執行緒池預設大小為 4，因為執行緒數變成了 11。
我們可以手動更改執行緒池預設大小：

process.env.UV_THREADPOOL_SIZE = 64

一行程式碼輕鬆把執行緒變成 71。

Libuv

Libuv 是一個跨平臺的非同步IO庫，它結合了UNIX下的libev和Windows下的IOCP的特性，最早由Node的作者開發，專門為Node提供多平臺下的非同步IO支援。Libuv本身是由C++語言實現的，Node中的非蘇塞IO以及事件迴圈的底層機制都是由libuv實現的。

libuv架構圖

在Window環境下，libuv直接使用Windows的IOCP來實現非同步IO。在非Windows環境下，libuv使用多執行緒來模擬非同步IO。

注意下面我要說的話，Node的非同步呼叫是由libuv來支援的，以上面的讀取檔案的例子，讀檔案實質的系統呼叫是由libuv來完成的，Node只是負責呼叫libuv的介面，等資料返回後再執行對應的回撥方法。

Node.js 執行緒建立

直到 Node 10.5.0 的釋出，官方才給出了一個實驗性質的模組 worker_threads 給 Node 提供真正的多執行緒能力。

先看下簡單的 demo：

const {
  isMainThread,
  parentPort,
  workerData,
  threadId,
  MessageChannel,
  MessagePort,
  Worker
} = require('worker_threads');

function mainThread() {
  for (let i = 0; i < 5; i++) {
    const worker = new Worker(__filename, { workerData: i });
    worker.on('exit', code => { console.log(`main: worker stopped with exit code ${code}`); });
    worker.on('message', msg => {
      console.log(`main: receive ${msg}`);
      worker.postMessage(msg + 1);
    });
  }
}

function workerThread() {
  console.log(`worker: workerDate ${workerData}`);
  parentPort.on('message', msg => {
    console.log(`worker: receive ${msg}`);
  }),
  parentPort.postMessage(workerData);
}

if (isMainThread) {
  mainThread();
} else {
  workerThread();
}

上述程式碼在主執行緒中開啟五個子執行緒，並且主執行緒向子執行緒傳送簡單的訊息。

由於 worker_thread 目前仍然處於實驗階段，所以啟動時需要增加 --experimental-worker flag，執行後觀察活動監視器，開啟了5個子執行緒

worker_thread 模組

worker_thread 核心程式碼（地址https://github.com/nodejs/nod...）
worker_thread 模組中有 4 個物件和 2 個類，可以自己去看上面的原始碼。

• isMainThread: 是否是主執行緒，原始碼中是通過 threadId === 0 進行判斷的。
• MessagePort: 用於執行緒之間的通訊，繼承自 EventEmitter。
• MessageChannel: 用於建立非同步、雙向通訊的通道例項。
• threadId: 執行緒 ID。
• Worker: 用於在主執行緒中建立子執行緒。第一個引數為 filename，表示子執行緒執行的入口。
• parentPort: 在 worker 執行緒裡是表示父程式的 MessagePort 型別的物件，在主執行緒裡為 null
• workerData: 用於在主程式中向子程式傳遞資料（data 副本）

總結

多程式 vs 多執行緒

對比一下多執行緒與多程式：

屬性	多程式	多執行緒	比較
資料	資料共享複雜，需要用IPC；資料是分開的，同步簡單	因為共享程式資料，資料共享簡單，同步複雜	各有千秋
CPU、記憶體	佔用記憶體多，切換複雜，CPU利用率低	佔用記憶體少，切換簡單，CPU利用率高	多執行緒更好
銷燬、切換	建立銷燬、切換複雜，速度慢	建立銷燬、切換簡單，速度很快	多執行緒更好
coding	編碼簡單、除錯方便	編碼、除錯複雜	編碼、除錯複雜
可靠性	程式獨立執行，不會相互影響	執行緒同呼吸共命運	多程式更好
分散式	可用於多機多核分散式，易於擴充套件	只能用於多核分散式	多程式更好

加入我們一起學習吧！

node學習交流群

交流群滿100人不能自動進群, 請新增群助手微訊號:【coder_qi】備註node，自動拉你入群。