前言

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

[[273852]]

文章導覽

面試會問

• Node.js是單線程嗎?
• Node.js 做耗時的計算時候，如何避免阻塞?
• Node.js如何實現(xiàn)多進程的開啟和關閉?
• Node.js可以創(chuàng)建線程嗎?
• 你們開發(fā)過程中如何實現(xiàn)進程守護的?
• 除了使用第三方模塊，你們自己是否封裝過一個多進程架構?

進程

進程Process是計算機中的程序關于某數(shù)據集合上的一次運行活動，是系統(tǒng)進行資源分配和調度的基本單位，是操作系統(tǒng)結構的基礎，進程是線程的容器(來自百科)。進程是資源分配的最小單位。我們啟動一個服務、運行一個實例，就是開一個服務進程，例如 Java 里的 JVM 本身就是一個進程，Node.js 里通過 node app.js 開啟一個服務進程，多進程就是進程的復制(fork)，fork 出來的每個進程都擁有自己的獨立空間地址、數(shù)據棧，一個進程無法訪問另外一個進程里定義的變量、數(shù)據結構，只有建立了 IPC 通信，進程之間才可數(shù)據共享。

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

const http = require('http');  
const server = http.createServer(); 
server.listen(3000,()=>{ 
    process.title='程序員成長指北測試進程'; 
    console.log('進程id',process.pid) 
}) 

運行上面代碼后，以下為 Mac 系統(tǒng)自帶的監(jiān)控工具 “活動監(jiān)視器” 所展示的效果，可以看到我們剛開啟的 Nodejs 進程 7663

線程

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

單線程

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

Javascript 就是屬于單線程，程序順序執(zhí)行(這里暫且不提JS異步)，可以想象一下隊列，前面一個執(zhí)行完之后，后面才可以執(zhí)行，當你在使用單線程語言編碼時切勿有過多耗時的同步操作，否則線程會造成阻塞，導致后續(xù)響應無法處理。你如果采用 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/大約需要15秒時間，也可以說一個用戶請求完第一個compute接口后需要等待15秒，這對于用戶來說是極其不友好的。下文我會通過創(chuàng)建多進程的方式child_process.fork 和cluster 來解決解決這個問題。

單線程的一些說明

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

Node.js 中的進程與線程

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

科普：在 Web 服務器方面，著名的 Nginx 也是采用此模式(事件驅動)，避免了多線程的線程創(chuàng)建、線程上下文切換的開銷，Nginx 采用 C 語言進行編寫，主要用來做高性能的 Web 服務器，不適合做業(yè)務。

Web業(yè)務開發(fā)中，如果你有高并發(fā)應用場景那么 Node.js 會是你不錯的選擇。

在單核 CPU 系統(tǒng)之上我們采用 單進程 + 單線程 的模式來開發(fā)。在多核 CPU 系統(tǒng)之上，可以通過 child_process.fork 開啟多個進程(Node.js 在 v0.8 版本之后新增了Cluster 來實現(xiàn)多進程架構) ，即 多進程 + 單線程 模式。注意：開啟多進程不是為了解決高并發(fā)，主要是解決了單進程模式下 Node.js CPU 利用率不足的情況，充分利用多核 CPU 的性能。

Node.js 中的進程

process 模塊

Node.js 中的進程 Process 是一個全局對象，無需 require 直接使用，給我們提供了當前進程中的相關信息。官方文檔提供了詳細的說明，感興趣的可以親自實踐下 Process 文檔。

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

以上僅列舉了部分常用到功能點，除了 Process 之外 Node.js 還提供了 child_process 模塊用來對子進程進行操作，在下文 Nodejs進程創(chuàng)建會繼續(xù)講述。

Node.js 進程創(chuàng)建

進程創(chuàng)建有多種方式，本篇文章以child_process模塊和cluster模塊進行講解。

child_process模塊

child_process 是 Node.js 的內置模塊，官網地址：

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

幾個常用函數(shù)：

四種方式

• child_process.spawn()：適用于返回大量數(shù)據，例如圖像處理，二進制數(shù)據處理。
• child_process.exec()：適用于小量數(shù)據，maxBuffer 默認值為 200 * 1024 超出這個默認值將會導致程序崩潰，數(shù)據量過大可采用 spawn。
• child_process.execFile()：類似 child_process.exec()，區(qū)別是不能通過 shell 來執(zhí)行，不支持像 I/O 重定向和文件查找這樣的行為
• child_process.fork()： 衍生新的進程，進程之間是相互獨立的，每個進程都有自己的 V8 實例、內存，系統(tǒng)資源是有限的，不建議衍生太多的子進程出來，通長根據系統(tǒng) CPU 核心數(shù)設置。

CPU 核心數(shù)這里特別說明下，fork 確實可以開啟多個進程，但是并不建議衍生出來太多的進程，cpu核心數(shù)的獲取方式const cpus = require('os').cpus();,這里 cpus 返回一個對象數(shù)組，包含所安裝的每個 CPU/內核的信息，二者總和的數(shù)組哦。假設主機裝有兩個cpu，每個cpu有4個核，那么總核數(shù)就是8。

fork開啟子進程 Demo

fork開啟子進程解決文章起初的計算耗時造成線程阻塞。

在進行 compute 計算時創(chuàng)建子進程，子進程計算完成通過 send 方法將結果發(fā)送給主進程，主進程通過 message 監(jiān)聽到信息后處理并退出。

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() 發(fā)送消息時會觸發(fā) 'message' 事件 
        compute.on('message', sum => { 
            res.end(`Sum is ${sum}`); 
            compute.kill(); 
        }); 
 
        // 子進程監(jiān)聽到一些錯誤消息退出 
        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 

針對文初需要進行計算的的例子我們創(chuàng)建子進程拆分出來單獨進行運算。

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()方法可以用來給父進程發(fā)送消息 
    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方法來創(chuàng)建子進程，該方法與child_process中的fork是同一個方法。

cluster模塊采用的是經典的主從模型，Cluster會創(chuàng)建一個master，然后根據你指定的數(shù)量復制出多個子進程，可以使用cluster.isMaster屬性判斷當前進程是master還是worker(工作進程)。由master進程來管理所有的子進程，主進程不負責具體的任務處理，主要工作是負責調度和管理。

cluster模塊使用內置的負載均衡來更好地處理線程之間的壓力，該負載均衡使用了Round-robin算法(也被稱之為循環(huán)算法)。當使用Round-robin調度策略時，master accepts()所有傳入的連接請求，然后將相應的TCP請求處理發(fā)送給選中的工作進程(該方式仍然通過IPC來進行通信)。

開啟多進程時候端口疑問講解：如果多個Node進程監(jiān)聽同一個端口時會出現(xiàn) Error:listen EADDRIUNS的錯誤，而cluster模塊為什么可以讓多個子進程監(jiān)聽同一個端口呢?原因是master進程內部啟動了一個TCP服務器，而真正監(jiān)聽端口的只有這個服務器，當來自前端的請求觸發(fā)服務器的connection事件后，master會將對應的socket具柄發(fā)送給子進程。

child_process 模塊與cluster 模塊總結

無論是 child_process 模塊還是 cluster 模塊，為了解決 Node.js 實例單線程運行，無法利用多核 CPU 的問題而出現(xiàn)的。核心就是父進程(即 master 進程)負責監(jiān)聽端口，接收到新的請求后將其分發(fā)給下面的 worker 進程。

cluster模塊的一個弊端：

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

Node.js進程通信原理

前面講解的無論是child_process模塊，還是cluster模塊，都需要主進程和工作進程之間的通信。通過fork()或者其他API，創(chuàng)建了子進程之后，為了實現(xiàn)父子進程之間的通信，父子進程之間才能通過message和send()傳遞信息。

IPC這個詞我想大家并不陌生，不管那一張開發(fā)語言只要提到進程通信，都會提到它。IPC的全稱是Inter-Process Communication,即進程間通信。它的目的是為了讓不同的進程能夠互相訪問資源并進行協(xié)調工作。實現(xiàn)進程間通信的技術有很多，如命名管道，匿名管道，socket，信號量，共享內存，消息隊列等。Node中實現(xiàn)IPC通道是依賴于libuv。windows下由命名管道(name pipe)實現(xiàn)，*nix系統(tǒng)則采用Unix Domain Socket實現(xiàn)。表現(xiàn)在應用層上的進程間通信只有簡單的message事件和send()方法，接口十分簡潔和消息化。

IPC創(chuàng)建和實現(xiàn)示意圖

IPC通信管道是如何創(chuàng)建的

父進程在實際創(chuàng)建子進程之前，會創(chuàng)建IPC通道并監(jiān)聽它，然后才真正的創(chuàng)建出子進程，這個過程中也會通過環(huán)境變量(NODE_CHANNEL_FD)告訴子進程這個IPC通道的文件描述符。子進程在啟動的過程中，根據文件描述符去連接這個已存在的IPC通道，從而完成父子進程之間的連接。

Node.js句柄傳遞

講句柄之前，先想一個問題，send句柄發(fā)送的時候，真的是將服務器對象發(fā)送給了子進程?

子進程對象send()方法可以發(fā)送的句柄類型

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

send句柄發(fā)送原理分析

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

 

 

send()方法在將消息發(fā)送到IPC管道前，實際將消息組裝成了兩個對象，一個參數(shù)是hadler，另一個是message。message參數(shù)如下所示：

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

發(fā)送到IPC管道中的實際上是我們要發(fā)送的句柄文件描述符。這個message對象在寫入到IPC管道時，也會通過JSON.stringfy()進行序列化。所以最終發(fā)送到IPC通道中的信息都是字符串，send()方法能發(fā)送消息和句柄并不意味著它能發(fā)送任何對象。

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

以發(fā)送的TCP服務器句柄為例，子進程收到消息后的還原過程代碼如下:

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

這段還原代碼，子進程根據message.type創(chuàng)建對應的TCP服務器對象，然后監(jiān)聽到文件描述符上。由于底層細節(jié)不被應用層感知，所以子進程中，開發(fā)者會有一種服務器對象就是從父進程中直接傳遞過來的錯覺。

Node進程之間只有消息傳遞，不會真正的傳遞對象，這種錯覺是抽象封裝的結果。目前Node只支持我前面提到的幾種句柄，并非任意類型的句柄都能在進程之間傳遞，除非它有完整的發(fā)送和還原的過程。

Node.js多進程架構模型

我們自己實現(xiàn)一個多進程架構守護Demo

 

 

編寫主進程

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

• 創(chuàng)建一個 server 并監(jiān)聽 3000 端口。
• 根據系統(tǒng) cpus 開啟多個子進程
• 通過子進程對象的 send 方法發(fā)送消息到子進程進行通信
• 在主進程中監(jiān)聽了子進程的變化，如果是自殺信號重新啟動一個工作進程。
• 主進程在監(jiān)聽到退出消息的時候，先退出子進程在退出主進程

// 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 子進程處理邏輯如下：

• 創(chuàng)建一個 server 對象，注意這里最開始并沒有監(jiān)聽 3000 端口
• 通過 message 事件接收主進程 send 方法發(fā)送的消息
• 監(jiān)聽 uncaughtException 事件，捕獲未處理的異常，發(fā)送自殺信息由主進程重建進程，子進程在鏈接關閉之后退出

// 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 服務意外崩潰了就不能自動重啟進程了。這些現(xiàn)象都不是我們想要看到的，所以需要通過某些方式來守護這個開啟的進程，執(zhí)行 node app.js 開啟一個服務進程之后，我還可以在這個終端上做些別的事情，且不會相互影響。，當出現(xiàn)問題可以自動重啟。

如何實現(xiàn)進程守護

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

pm2 指定生產環(huán)境啟動一個名為 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 參數(shù)用來告訴PM2以cluster_mode的形式運行你的app(對應的叫fork_mode)，后面的數(shù)字表示要啟動的工作線程的數(shù)量。如果給定的數(shù)字為0，PM2則會根據你CPU核心的數(shù)量來生成對應的工作線程。注意一般在生產環(huán)境使用cluster_mode模式，測試或者本地環(huán)境一般使用fork模式，方便測試到錯誤。
• pm2 reload Name pm2 restart Name 應用程序代碼有更新，可以用重載來加載新代碼，也可以用重啟來完成,reload可以做到0秒宕機加載新的代碼，restart則是重新啟動，生產環(huán)境中多用reload來完成代碼更新!
• pm2 show Name 查看服務詳情
• pm2 list 查看pm2中所有項目
• pm2 monit用monit可以打開實時監(jiān)視器去查看資源占用情況

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 

上面是執(zhí)行命令后在linux中顯示的結果，第二個參數(shù)就是進程對應的PID

• 殺死進程

1. 以優(yōu)雅的方式結束進程

kill -l PID

-l選項告訴kill命令用好像啟動進程的用戶已注銷的方式結束進程。

當使用該選項時，kill命令也試圖殺死所留下的子進程。

但這個命令也不是總能成功--或許仍然需要先手工殺死子進程，然后再殺死父進程。

1. kill 命令用于終止進程

例如： kill -9 [PID]

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

這個強大和危險的命令迫使進程在運行時突然終止，進程在結束后不能自我清理。

危害是導致系統(tǒng)資源無法正常釋放，一般不推薦使用，除非其他辦法都無效。

當使用此命令時，一定要通過ps -ef確認沒有剩下任何僵尸進程。

只能通過終止父進程來消除僵尸進程。如果僵尸進程被init收養(yǎng)，問題就比較嚴重了。

殺死init進程意味著關閉系統(tǒng)。

如果系統(tǒng)中有僵尸進程，并且其父進程是init，

而且僵尸進程占用了大量的系統(tǒng)資源，那么就需要在某個時候重啟機器以清除進程表了。

1. killall命令

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

killall httpd

Node.js 線程

Node.js關于單線程的誤區(qū)

const http = require('http'); 
 
const server = http.createServer(); 
server.listen(3000,()=>{ 
    process.title='程序員成長指北測試進程'; 
    console.log('進程id',process.pid) 
}) 

仍然看本文第一段代碼，創(chuàng)建了http服務，開啟了一個進程，都說了Node.js是單線程，所以 Node 啟動后線程數(shù)應該為 1，但是為什么會開啟7個線程呢?難道Javascript不是單線程不知道小伙伴們有沒有這個疑問?

解釋一下這個原因：

Node 中最核心的是 v8 引擎，在 Node 啟動后，會創(chuàng)建 v8 的實例，這個實例是多線程的。

• 主線程：編譯、執(zhí)行代碼。
• 編譯/優(yōu)化線程：在主線程執(zhí)行的時候，可以優(yōu)化代碼。
• 分析器線程：記錄分析代碼運行時間，為 Crankshaft 優(yōu)化代碼執(zhí)行提供依據。
• 垃圾回收的幾個線程。

所以大家常說的 Node 是單線程的指的是 JavaScript 的執(zhí)行是單線程的(開發(fā)者編寫的代碼運行在單線程環(huán)境中)，但 Javascript 的宿主環(huán)境，無論是 Node 還是瀏覽器都是多線程的因為libuv中有線程池的概念存在的，libuv會通過類似線程池的實現(xiàn)來模擬不同操作系統(tǒng)的異步調用，這對開發(fā)者來說是不可見的。

某些異步 IO 會占用額外的線程

還是上面那個例子，我們在定時器執(zhí)行的同時，去讀一個文件：

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

線程數(shù)量變成了 11 個，這是因為在 Node 中有一些 IO 操作(DNS，F(xiàn)S)和一些 CPU 密集計算(Zlib，Crypto)會啟用 Node 的線程池，而線程池默認大小為 4，因為線程數(shù)變成了 11。

我們可以手動更改線程池默認大小：

process.env.UV_THREADPOOL_SIZE = 64 

一行代碼輕松把線程變成 71。

Libuv

Libuv 是一個跨平臺的異步IO庫，它結合了UNIX下的libev和Windows下的IOCP的特性，最早由Node的作者開發(fā)，專門為Node提供多平臺下的異步IO支持。Libuv本身是由C++語言實現(xiàn)的，Node中的非蘇塞IO以及事件循環(huán)的底層機制都是由libuv實現(xiàn)的。

libuv架構圖

 

 

在Window環(huán)境下，libuv直接使用Windows的IOCP來實現(xiàn)異步IO。在非Windows環(huán)境下，libuv使用多線程來模擬異步IO。

注意下面我要說的話，Node的異步調用是由libuv來支持的，以上面的讀取文件的例子，讀文件實質的系統(tǒng)調用是由libuv來完成的，Node只是負責調用libuv的接口，等數(shù)據返回后再執(zhí)行對應的回調方法。

Node.js 線程創(chuàng)建

直到 Node 10.5.0 的發(fā)布，官方才給出了一個實驗性質的模塊 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(); 
} 

上述代碼在主線程中開啟五個子線程，并且主線程向子線程發(fā)送簡單的消息。

由于 worker_thread 目前仍然處于實驗階段，所以啟動時需要增加 --experimental-worker flag，運行后觀察活動監(jiān)視器，開啟了5個子線程

 

 

worker_thread 模塊

worker_thread 核心代碼(地址https://github.com/nodejs/nod...)

worker_thread 模塊中有 4 個對象和 2 個類，可以自己去看上面的源碼。

• isMainThread: 是否是主線程，源碼中是通過 threadId === 0 進行判斷的。
• MessagePort: 用于線程之間的通信，繼承自 EventEmitter。
• MessageChannel: 用于創(chuàng)建異步、雙向通信的通道實例。
• threadId: 線程 ID。
• Worker: 用于在主線程中創(chuàng)建子線程。第一個參數(shù)為 filename，表示子線程執(zhí)行的入口。
• parentPort: 在 worker 線程里是表示父進程的 MessagePort 類型的對象，在主線程里為 null
• workerData: 用于在主進程中向子進程傳遞數(shù)據(data 副本)

總結

多進程 vs 多線程

對比一下多線程與多進程：