山東標梵簡單分析下 Node.js 關於集羣的那些事

須要瞭解的基礎概念 一個應用程序中，至少包含一個進程，一個進程至少包含一個線程。

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位
線程（Thread）是操做系統可以進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運做單位。
Node 的特色：

主線程是單進程(後面版本出現了線程概念，開銷較大)；
基於事件驅動，異步非阻塞 I/O;
可用於高併發場景。
nodejs 原有版本中沒有實現多線程，爲了充分利用多核 cpu,能夠使用子進程實現內核的負載均衡。

node 須要解決的問題：

node 作耗時的計算時候，形成阻塞。
node 如何開啓子進程
開發過程當中如何實現進程守護
概念太多，咱們從具體案例入手，看看單線程到底會帶來什麼問題。

單線程的缺點
// file: question.js
const http = require('http');
http.createServer((req, res) => {
if (req.url === '/sum') { // 求和

var endTime = new Date().getTime() + 10000
while (new Date().getTime() < endTime) {}
res.end('sum')

} else {

res.end('end');

}
}).listen(3000);
操做步驟

node question.js
打開瀏覽器，在一個 tab1 上訪問 /sum 。快速打開另外一個 tab2，訪問 / 。
請問會出現什麼現象？ 咱們發現 tab1 在轉圈， tab2 也在轉圈，這個現象就很奇怪了。tab1 在轉圈咱們能夠理解，由於咱們須要花費是 10s，可是 tab2 也須要 10s 後，才能被訪問。這就很奇怪了。

這個問題就至關於，別人訪問這個瀏覽器阻塞了 10s，你也要跟着阻塞 10s。這個問題就很難被接受了。所以得出結論，node 不太適合作 cpu 密集型的服務。

如何解決這個問題？
爲了解決這個問題，咱們引入子進程。

file: calc.js

var endTime = new Date().getTime() + 10000
while (new Date().getTime() < endTime) {}

process.send({

time: new Date().getTime()+''

});
改造 question.js

file: question.js
const http = require('http');
const {fork} = require('child_process');
const path = require('path');
http.createServer((req, res) => {
if (req.url === '/sum') { // 求和

// var endTime = new Date().getTime() + 10000
  // while (new Date().getTime() < endTime) {}
  // res.end('sum')
  let childProcess = fork('calc.js', {
    cwd: path.resolve(__dirname)
  });
  childProcess.on('message', function (data) {
    res.end(data.time + '');
  })

} else {

res.end('end');

}
}).listen(3001);
從新啓動 node question.js，發現 tab2,就不會阻塞了。

總結：node 做爲服務器的話，須要開啓子進程來解決 cpu 密集型的操做。以防止主線程被阻塞

子進程的使用 (child_process)
使用的方法

spawn 異步生成子進程
fork 產生一個新的 Node.js 進程，並使用創建的 IPC 通訊通道調用指定的模塊，該通道容許在父級和子級之間發送消息。
exec 產生一個 shell 並在該 shell 中運行命令
execFile 無需產生 shell
spawn
spawn 產卵，能夠經過此方法建立一個子進程

let { spawn } = require("child_process");
let path = require("path");
// 經過node命令執行sub_process.js文件
let childProcess = spawn("node",['sub_process.js'], {
cwd: path.resolve(__dirname, "test"), // 找文件的目錄是test目錄下
stdio: [0, 1, 2]
});
// 監控錯誤
childProcess.on("error", function(err) {
console.log(err);
});
// 監聽關閉事件
childProcess.on("close", function() {
console.log("close");
});
// 監聽退出事件
childProcess.on("exit", function() {
console.log("exit");
});
stdio 這個屬性很是有特點，這裏咱們給了 0,1,2 那麼分別表明什麼呢？ stdio

0,1,2 分別對應當前主進程的 process.stdin,process.stdout,process.stderr,意味着主進程和子進程共享標準輸入和輸出
let childProcess = spawn("node",['sub_process.js'], {
cwd: path.resolve(__dirname, "test"), // 找文件的目錄是test目錄下
stdio: [0, 1, 2]
});
能夠在當前進程下打印 sub_process.js 執行結果

默認不提供 stdio 參數時，默認值爲 stdio:['pipe']，也就是隻能經過流的方式實現進程之間的通訊
let { spawn } = require("child_process");
let path = require("path");
// 經過node命令執行sub_process.js文件
let childProcess = spawn("node",['sub_process.js'], {
cwd: path.resolve(__dirname, "test"),
stdio:['pipe'] // 經過流的方式
});
// 子進程讀取寫入的數據
childProcess.stdout.on('data',function(data){

console.log(data);

});
// 子進程像標準輸出中寫入
process.stdout.write('hello');
使用 ipc 方式通訊,設置值爲 stdio:['pipe','pipe','pipe','ipc'],能夠經過 on('message')和 send 方法進行通訊
let { spawn } = require("child_process");
let path = require("path");
// 經過node命令執行sub_process.js文件
let childProcess = spawn("node",['sub_process.js'], {

cwd: path.resolve(__dirname, "test"),
stdio:['pipe','pipe','pipe','ipc'] // 經過流的方式

});
// 監聽消息
childProcess.on('message',function(data){

console.log(data);

});
// 發送消息
process.send('hello');
還能夠傳入ignore 進行忽略 , 傳入inherit表示默認共享父進程的標準輸入和輸出
產生獨立進程
let { spawn } = require("child_process");
let path = require("path");
// 經過node命令執行sub_process.js文件
let child = spawn('node',['sub_process.js'],{

cwd:path.resolve(__dirname,'test'),
stdio: 'ignore',
detached:true // 獨立的線程

});
child.unref(); // 放棄控制
做用：開啓線程後，而且放棄對線程的控制。咱們就能夠不佔用控制太后臺運行了。

fork
衍生新的進程,默認就能夠經過ipc方式進行通訊

let { fork } = require("child_process");
let path = require("path");
// 經過node命令執行sub_process.js文件
let childProcess = fork('sub_process.js', {
cwd: path.resolve(__dirname, "test"),
});
childProcess.on('message',function(data){

console.log(data);

});
fork是基於spawn的，能夠多傳入一個silent屬性, 設置是否共享輸入和輸出

fork原理

function fork(filename,options){

let stdio = ['inherit','inherit','inherit']
if(options.silent){ // 若是是安靜的  就忽略子進程的輸入和輸出
    stdio = ['ignore','ignore','ignore']
}
stdio.push('ipc'); // 默認支持ipc的方式
options.stdio = stdio
return spawn('node',[filename],options)

}
execFile
經過node命令,直接執行某個文件

let childProcess = execFile("node",['./test/sub_process'],function(err,stdout,stdin){

console.log(stdout);

});
內部調用的是spawn方法

exec
let childProcess = exec("node './test/sub_process'",function(err,stdout,stdin){

console.log(stdout)

});
內部調用的是execFile,其實以上的三個方法都是基於spawn的

實現集羣
// file cluster.js 主線程
// 內部原理就是多進程
// 分佈式 前端和後端 集羣 多個功能相同的來分擔工做
// 集羣 就能夠實現多個cpu的負載均衡 通常狀況
// 不一樣進程 監聽同一個端口號
const {fork} = require('child_process');
const cpus = require('os').cpus().length;
const path = require('path');

// 如今主進程中先啓動一個服務
const http = require('http');
let server = http.createServer(function (req,res) {

res.end(process.pid+' '+ ' main end')

}).listen(3000);

for(let i = 0 ; i < cpus-1 ; i++ ){

let cp = fork('server.js',{cwd:path.resolve(__dirname,'worker'),stdio:[0,1,2,'ipc']});
cp.send('server',server); // 我能夠在ipc 模式下第二個參數傳入一個http服務 或者tcp服務

}
// 多個請求都是i/o密集
// cluster 集羣
// file worker/server.js 子進程
const http = require('http');

process.on('message',function (data,server) {

http.createServer(function (req,res) {
    
    res.end(process.pid+' '+ 'end')
}).listen(server); // 多進程監控同一個端口號

})

// file http.get.js 請求腳本
const http = require('http');

for(let i =0 ; i < 10000;i++){

http.get({
    port:3000,
    hostname:'localhost'
},function (res) {
    res.on('data',function (data) {
        console.log(data.toString())
    })
})

}
啓動請求腳本之後，屢次發送請，能夠清楚的發現請求的進程pid 不是同一個pid。

cluster模塊實現集羣
let cluster = require("cluster");
let http = require("http");
let cpus = require("os").cpus().length;
const workers = {};
if (cluster.isMaster) {

cluster.on('exit',function(worker){
    console.log(worker.process.pid,'death')
    let w = cluster.fork();
    workers[w.pid] = w;
})

for (let i = 0; i < cpus; i++) {

let worker = cluster.fork();
workers[worker.pid] = worker;

}
} else {
http

.createServer((req, res) => {
  res.end(process.pid+'','pid');
})
.listen(3000);

console.log("server start",process.pid);
}
上訴的代碼有點反人類，可是 c++ 中也是存在這樣操做進程的。

另外一種方式

// file

const cluster = require('cluster');
const cpus = require('os').cpus();

// 入口文件

cluster.setupMaster({

exec: require('path').resolve(__dirname,'worker/cluster.js'),

});

cluster.on('exit',function (worker) {

console.log(worker.process.pid);
cluster.fork(); // 在開啓個進程

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

cluster.fork(); // child_process fork  會以當前文件建立子進程
// 而且isMaster 爲false 此時就會執行else方法

}
// pm2 專門 開啓 重啓 直接採用集羣的方式
// 模塊
// node worker/cluster.js
// 咱們的項目邏輯不少
const http = require('http');
http.createServer((req, res) => {

if (Math.random() > 0.5) {
  SDSADADSSA();
}
// 在集羣的環境下能夠監聽同一個端口號
res.end(process.pid + ':' + 'end')

}).listen(3000);
pm2應用
pm2能夠把你的應用部署到服務器全部的CPU上,實現了多進程管理、監控、及負載均衡

安裝pm2
npm install pm2 -g # 安裝pm2
pm2 start server.js --watch -i max # 啓動進程
pm2 list # 顯示進程狀態
pm2 kill # 殺死所有進程
pm2 start npm -- run dev # 啓動npm腳本
pm2配置文件
pm2 ecosystem
配置項目自動部署
module.exports = {
apps : [{

name: 'my-project',
script: 'server.js',
// Options reference: https://pm2.io/doc/en/runtime/reference/ecosystem-file/
args: 'one two',
instances: 2,
autorestart: true,
watch: false,
max_memory_restart: '1G',
env: {
  NODE_ENV: 'development'
},
env_production: {
  NODE_ENV: 'production'
}

}],
deploy : {

production : {
  user : 'root',
  host : '39.106.14.146',
  ref  : 'origin/master',
  repo : 'https://github.com/wakeupmypig/pm2-deploy.git',
  path : '/home',
  'post-deploy' : 'npm install && pm2 reload ecosystem.config.js --env production'
}

}
};
pm2 deploy ecosystem.config.js production setup # 執行git clone
pm2 deploy ecosystem.config.js production # 啓動pm2

文章來源:Biaofun標梵互動(https://www.biaofun.com/)