node 进程管理

前言

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等工具，无需手动处理。