深入理解Node.js 進程與線程(8000長文徹底搞懂)

前言

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

文章導覽

16c6cf612c275894?w=2772&h=1104&f=jpeg&s=377258

面試會問

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

16c4dc0ca13fec40?w=1406&h=1182&f=jpeg&s=131412

線程

線程是操作系統能夠進行運算調度的最小單位,首先我們要清楚線程是隸屬於進程的,被包含於進程之中。一個線程只能隸屬於一個進程,但是一個進程是可以擁有多個線程的

單線程

單線程就是一個進程只開一個線程

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.forkcluster 來解決解決這個問題。

單線程的一些說明

  • 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原理分析

16c5658b2e97e9b2

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模塊的一個弊端:

16c565aaeb065b4a?w=501&h=261&f=png&s=23033

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創建和實現示意圖

16c5b379ad12199e?w=391&h=311&f=png&s=23661

IPC通信管道是如何創建的

16c5b3812e3bb7d9?w=866&h=612&f=jpeg&s=103501

父進程在實際創建子進程之前,會創建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句柄發送原理分析

結合句柄的發送與還原示意圖更容易理解。

16c5b52b15d87bbe?w=916&h=548&f=png&s=82815
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

16c565f2d5b5e5c2?w=533&h=352&f=png&s=47188
編寫主進程

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架構圖

16c565ec3aaa0424?w=323&h=156&f=jpeg&s=7864

在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個子線程

16c6cfb939b5b268?w=1306&h=238&f=jpeg&s=49232

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 編碼簡單、調試方便 編碼、調試複雜 編碼、調試複雜
可靠性 進程獨立運行,不會相互影響 線程同呼吸共命運 多進程更好
分佈式 可用於多機多核分佈式,易於擴展 只能用於多核分佈式 多進程更好

加入我們一起學習吧!

16b8a3d23a52b7d0?w=940&h=400&f=jpeg&s=217901
node學習交流羣

交流羣滿100人不能自動進羣, 請添加羣助手微信號:【coder_qi】備註node,自動拉你入羣。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章