前言
node是单线程且支持高并发的脚本语言，node如何能做到单线程不阻塞，基于i/o的操作基本都是异步的，node主线程只需发送异步操作给libuv，由node的工作线程去执行，libuv是多线程的线程池用来并行io操作，主线程就可以做其他的事情，直到libuv的返回，所以node是i/o非阻塞。可以理解node并不是单纯的单线程，只是js运行是单线程的。所以node非常适合与I/O密集型的系统。虽然node是开启了多线程，但是所有的多线程都是基于node服务进程开启的，所以并不能充分利用cpu，一个node实例，只能利用一个cpu核心，故node不适合cpu密集型系统，nodejs是单线程的，进行密集型的运算会导致主线程挂起。
说明
- node 在运行时只生成了一个 javascript 运行环境
- node 只把 libuv 的 io/timer 接口提供给了 js 引擎
- js 引擎没有异步，因为 js 引擎是在 node 的主线程调用
多进程
- 由于单进程单线程，无法充分利用cpu资源
- 采用多进程去处理，也就是一个进程利用一个cpu资源
child_process node提供的核心模块
// worker 进程
'use strict';
const http = require('http');
http.createServer(function(req, res) {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello World');
}).listen(Math.round((1 + Math.random()) * 1000), '127.0.0.1');
//master 进程
'use strict';
const child_process = require('child_process');
const cpu = require('os').cpus();
for (let i = 0; i < cpu.length; i++) {
child_process.fork('./worker.js');
}
利用child_process的fork方法，我们可以fork出多个进程。
image.png
目前基于master-work模型如下:
image.png
进程ipc
- 采用master-work模型，需要master对work进程之前进行通信
- fork创建子进程后，父进程与子进程之间将会创建IPC通道，通过IPC通道，父子进程之间才能通过message和send()传递消息
// master
'use strict';
const child_process = require('child_process');
const cpu = require('os').cpus();
for (let i = 0; i < cpu.length; i++) {
let child = child_process.fork('./worker.js');
child.on('message', function (m) {
console.log('parent got message:', m);
});
child.send({ hello: 'I am parent' });
}
//work
'use strict';
const http = require('http');
http.createServer(function(req, res) {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello World');
}).listen(Math.round((1 + Math.random()) * 1000), '127.0.0.1');
process.on('message', function (m) {
console.log('child got message:', m);
});
process.send({ hello: 'I am child' });
- 此时并不能4个work进程监听同一个端口，通常的做法是，让master监听一个端口，类似与一个代理处理负载均衡，此时master与work之间的通信就变得复杂，node提供的 process.send(message, [sendHandle]) ，可以放我们传入一个handler句柄。
// master
'use strict';
const child_process = require('child_process');
const cpu = require('os').cpus();
const server = require('net').createServer();
const works = [];
server.on('connection', function(socket) {
socket.end('handled by parent');
});
for (let i = 0; i < cpu.length; i++) {
const child = child_process.fork('./worker.js');
works.push(child);
}
server.listen(80, function() {
for (let i = 0; i < works.length; i++) {
works[i].send('server', server);
}
server.close();
});
// work
'use strict';
const http = require('http');
const server = http.createServer(function(req, res) {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('handled by child, pid is ' + process.pid + '\n');
});
process.on('message', function(m, tcp) {
if (m === 'server') {
tcp.on('connection', function(socket) {
server.emit('connection', socket);
});
}
});
- 此时我们的结构如下：
image.png
image.png
这样就完成了，多个进程同时监听同一个端口
自动重启
'use strict';
const child_process = require('child_process');
const cpu = require('os').cpus();
const server = require('net').createServer();
server.listen(80);
const workers = {};
server.on('connection', function(socket) {
socket.end('handled by parent');
});
const createWorker = function() {
const child = child_process.fork('./worker.js');
child.send('server', server);
workers[child.pid] = child;
console.log('Create worker. pid: ' + child.pid);
child.on('exit', function() {
console.log('Worker ' + child.pid + ' exited.');
delete workers[child.pid];
createWorker();
});
};
for (let i = 0; i < cpu.length; i++) {
createWorker();
}
process.on('exit', function() {
for (const pid in workers) {
workers[pid].kill();
}
});
// 当某个work进程异常时，就会自动东西启动一个新的进程处理
数据共享
一般有2种方案
- 数据存储在master中
- 引用外部存储机制如redis，文件，db
cluster 核心模块
官方提供用法：
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`主进程 ${process.pid} 正在运行`);
// 衍生工作进程。
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('exit', (worker, code, signal) => {
console.log(`工作进程 ${worker.process.pid} 已退出`);
});
} else {
// 工作进程可以共享任何 TCP 连接。
// 在本例子中，共享的是一个 HTTP 服务器。
http.createServer((req, res) => {
res.writeHead(200);
res.end('你好世界\n');
}).listen(8000);
console.log(`工作进程 ${process.pid} 已启动`);
}
cluster其实是net跟child_proccess 的封装
注意
除非自定义一些进程处理机制，手动管理进程的调度，一般建议用成熟的框架pm2.0、forever等工具，无需手动处理。
