node.js多進程架構

node.js是單進程應用，要充分利用多核cpu的性能，就需要用到多進程架構。

作為web服務器，不能多個進程創建不同的socket文件描述符去accept網絡請求， 有經驗的同學知道，如果端口被占用了，再跑一個監聽該端口的服務就會報EADDRINUSE異常。那么問題來了，多進程架構如何去解決這個問題？

 

我們把多進程架構設計成典型的master-workers架構， 一個master, 多個worker。

 

master-workers架構如下圖所示：

 

 

我們可以在master進程代理accept請求然后分配給worker處理。但客戶端進程連接到master進程，master進程連接到worker進程需要用掉兩個文件描述符，會浪費掉一倍數量的文件描述符。

所以交由worker來accept請求會是更好的方案。

 

master先創建一個server監聽端口，然后通過進程間通信，把socket文件描述符傳遞給所有的worker進程， worker進程用傳遞過來的socket文件描述符封裝成server（感官上好像是把一個server對象發送給另一個進程，其實是把相應的句柄封裝后，通過JSON.stringify()序列化再發送， 接收端進程還原成相應的句柄。）

 

然后，還有一個問題，假如其中一個worker進程異常退出了怎么辦， 這個時候，worker進程應該要通知到master進程，然后master進程重新fork一個worker進程。

 

先上master的代碼：

"use strict"

const fork = require('child_process').fork;
const cpus = require('os').cpus();
let server = require('net').createServer((socket)=>{
    // ‘connection’ 監聽器
    socket.end('Handled by master \n');
    console.error('Handled by master \n');   //不應該在master accept請求
});


server.listen(8001);

let workers = {};

function createWorker(ser) {
    let worker = fork('./worker.js');

    worker.on('message', function(msg, handle) {
        // 收到子進程通知需要創建新的worker(子進程退出前通知父進程)
        if(msg ==='new_worker') {
            let ser = handle;
            createWorker(ser);
            // 關掉
            ser.close();
        }
    })


    worker.on('exit', function(code, signal){
        delete workers[worker.pid];
    });

    // 句柄轉發 
    let result = worker.send('server', ser, (err)=> {err&&console.error(err)});
    console.info('send server to child result:', result);
    workers[worker.pid] = worker;
}

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

// 關掉，不再accept端口請求
server.close();

/*
code <number> The exit code if the child exited on its own.
signal <string> The signal by which the child process was terminated.
 */
process.on('exit', function(code, signal) {
    console.log(`master exit, code:${code}, signal:${signal}`);
    for(let pid in workers) {
        workers[pid].kill();
    }
})

process.on('uncaughtException', function(error) {
    console.error('master | uncaughtException, error:', error);
    process.exit(1);
})

//一些常用的退出信號的處理:
// kill pid 默認是SIGTERM信號
// 控制台 ctrl-c 是SIGINT信號
const killSignalList = ['SIGTERM', 'SIGINT'];
killSignalList.forEach((SIGNAL)=>{
    process.on(SIGNAL, function(){
        console.log(`${SIGNAL} signal`);
        process.exit(1);
    })  
})

 

 

master進程根據cpu核數fork相應數量的worker進程， fork成功后馬上把server句柄發送給worker進程， fork所有worker進程后， 就把server關掉，不再接收請求。 master進程退出前會調用worker的kill()方法殺掉所有worker進程。

 

 

worker代碼如下：

const http = require('http');


const server = http.createServer(function(req, res) {
     // ‘request’ 監聽器
    res.end('handled by worker \n');
    // throw new Error('error');
})

let worker;
process.on('message', function(msg, handle){
    if(msg === 'server') {
        worker = handle;
        worker.on('connection', function(socket){
            server.emit('connection', socket);
        })
    }

})


process.on('uncaughtException', function(err) {
    console.error('uncaughtException err:', err.message, ', worker進程將重啟');
    // 通知master創建新的worker
    process.send('new_worker', worker);
    // 停止接收新的連接
    worker.close(function() {
        // 所有已有連接斷開后，退出進程
        process.exit(1);
    });
});

 

 

 worker進程有個細節處理的地方： 異常退出前，先通知master進程創建新的worker, 然后等待所有已有連接斷開后再退出進程。

 

關於進程間的句柄發送功能， 有興趣的同學可以再去了解一下， 子進程對象send(message,[sendHandle])方法可以發送的句柄類型有：

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

 

多個worker進程監聽同一個套接字，會導致驚群現象， 有請求過來時cpu會喚醒所有的worker進程， 最終只有一個進程accept到請求， 其它進程accept請求失敗，這種情況會產生一些不必要的開銷。 如何避免驚群現象，我另外寫一篇文章具體說一下。