深刻理解Node.js 中的進程與線程

前言

進程與線程是一個程序員的必知概念，面試常常被問及，可是一些文章內容只是講講理論知識，可能一些小夥伴並無真的理解，在實際開發中應用也比較少。本篇文章除了介紹概念，經過Node.js 的角度講解進程與線程，而且講解一些在項目中的實戰的應用，讓你不只能迎戰面試官還能夠在實戰中完美應用。javascript

文章導覽

做者簡介：koala，專一完整的 Node.js 技術棧分享，從 JavaScript 到 Node.js,再到後端數據庫，祝您成爲優秀的高級 Node.js 工程師。【程序員成長指北】做者，Github 博客開源項目 github.com/koala-codin…html

面試會問

Node.js是單線程嗎？前端

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

Node.js如何實現多進程的開啓和關閉？node

Node.js能夠建立線程嗎？linux

大家開發過程當中如何實現進程守護的？git

除了使用第三方模塊，大家本身是否封裝過一個多進程架構?程序員

進程

進程Process是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操做系統結構的基礎，進程是線程的容器（來自百科）。進程是資源分配的最小單位。咱們啓動一個服務、運行一個實例，就是開一個服務進程，例如 Java 裏的 JVM 自己就是一個進程，Node.js 裏經過 node app.js 開啓一個服務進程，多進程就是進程的複製（fork），fork 出來的每一個進程都擁有本身的獨立空間地址、數據棧，一個進程沒法訪問另一個進程裏定義的變量、數據結構，只有創建了 IPC 通訊，進程之間纔可數據共享。github

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 官網地址：nodejs.cn/api/child_p…

幾個經常使用函數：四種方式

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 參數用來告訴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 官網地址：

pm2.keymetrics.io/docs/usage/…

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

github.com/foreverjs/f…

注意：兩者更推薦pm2，看一下兩者對比就知道我爲何更推薦使用pm2了。www.jianshu.com/p/fdc12d82b…

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
複製代碼

殺死進程

以優雅的方式結束進程

kill -l PID

-l選項告訴kill命令用好像啓動進程的用戶已註銷的方式結束進程。當使用該選項時，kill命令也試圖殺死所留下的子進程。但這個命令也不是總能成功--或許仍然須要先手工殺死子進程，而後再殺死父進程。
kill 命令用於終止進程

例如： `kill -9 [PID]`
複製代碼

-9 表示強迫進程當即中止

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

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/node/blob/master/lib/worker_threads.js） 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中child_process模塊的使用:juejin.cn/post/684490…
樸靈老師的書籍【Node.js 深刻淺出】
淘寶前端團隊cluster講解:taobaofed.org/blog/2015/1…

加入咱們一塊兒學習吧！

node學習交流羣