通过Node.js的Cluster模块源码，深入PM2原理-node.js的核心模块

[[285104]]

Node.js无疑是走向大前端、全栈工程师技术栈最快的捷径（但是一定要会一门其他后台语言，推荐Golang），虽然Node.js做很多事情都做不好，但是在某些方面还是有它的优势。

众所周知，Node.js中的JavaScript代码执行在单线程中，非常脆弱，一旦出现了未捕获的异常，那么整个应用就会崩溃。

这在许多场景下，尤其是web应用中，是无法忍受的。通常的解决方案，便是使用Node.js中自带的cluster模块，以master-worker模式启动多个应用实例。然而大家在享受cluster模块带来的福祉的同时，不少人也开始好奇

1.为什么我的应用代码中明明有app.listen(port);，但cluter模块在多次fork这份代码时，却没有报端口已被占用？

2.Master是如何将接收的请求传递至worker中进行处理然后响应的？

带着这些疑问我们开始往下看

TIPS：

本文编写于2019年12月8日，是最新版本的Node.js源码

Cluster源码解析：

入口：

const childOrMaster = 'NODE_UNIQUE_ID' in process.env ? 'child' : 'master';  
module.exports = require(`internal/cluster/${childOrMaster}`);

分析

会根据一个当前的Node_UNIQUE_ID（后面会讲）是否在环境变量中判断是子进程还是主进程，然后引用不同的js代码

NODE_UNIQUE_ID是一个唯一标示，Node.js的Cluster多进程模式，采用默认的调度算法是round-robin,其实就是轮询.官方解释是实践效率非常高，稳定

之前的问题一：为什么我的应用代码中明明有app.listen(port);，但cluter模块在多次fork这份代码时，却没有报端口已被占用？

我在Node.js的官网找到了答案：

原来所有的net.Socket都被设置了SO_REUSEADDR

这个SO_REUSEADDR到底是什么呢？

为什么需要 SO_REUSEADDR 参数？

服务端主动断开连接以后，需要等 2 个 MSL 以后才最终释放这个连接，重启以后要绑定同一个端口，默认情况下，操作系统的实现都会阻止新的监听套接字绑定到这个端口上。

我们都知道 TCP 连接由四元组唯一确定。形式如下

{local-ip-address:local-port , foreign-ip-address:foreign-port}

一个典型的例子如下图

TCP 要求这样的四元组必须是唯一的，但大多数操作系统的实现要求更加严格，只要还有连接在使用这个本地端口，则本地端口不能被重用（bind 调用失败）

启用 SO_REUSEADDR 套接字选项可以解除这个限制，默认情况下这个值都为 0，表示关闭。在 Java 中，reuseAddress 不同的 JVM 有不同的实现，在我本机上，这个值默认为 1 允许端口重用。但是为了保险起见，写 TCP、HTTP 服务一定要主动设置这个参数为 1。

目前常见的网络编程模型就是多进程或多线程，根据accpet的位置，分为如下场景

2种场景

(1) 单进程或线程创建socket，并进行listen和accept，接收到连接后创建进程和线程处理连接

(2) 单进程或线程创建socket，并进行listen，预先创建好多个工作进程或线程accept()在同一个服务器套接字

这两种模型解充分发挥了多核CPU的优势,虽然可以做到线程和CPU核绑定，但都会存在：

1.单一listener工作进程或线程在高速的连接接入处理时会成为瓶颈

2.多个线程之间竞争获取服务套接字

3.缓存行跳跃

4.很难做到CPU之间的负载均衡

5.随着核数的扩展，性能并没有随着提升

6.SO_REUSEPORT解决了什么问题

7.SO_REUSEPORT支持多个进程或者线程绑定到同一端口，提高服务器程序的性能

解决的问题：

1.允许多个套接字 bind()/listen() 同一个TCP/UDP端口

2.每一个线程拥有自己的服务器套接字

3.在服务器套接字上没有了锁的竞争

4.内核层面实现负载均衡

5.安全层面，监听同一个端口的套接字只能位于同一个用户下面

其核心的实现主要有三点：

1.扩展 socket option，增加 SO_REUSEPORT 选项，用来设置 reuseport

2.修改 bind 系统调用实现，以便支持可以绑定到相同的 IP 和端口

3.修改处理新建连接的实现，查找 listener 的时候，能够支持在监听相同 IP 4.和端口的多个 sock 之间均衡选择。

5.有了SO_RESUEPORT后，每个进程可以自己创建socket、bind、listen、accept相同的地址和端口，各自是独立平等的

让多进程监听同一个端口，各个进程中accept socket fd不一样，有新连接建立时，内核只会唤醒一个进程来accept，并且保证唤醒的均衡性。

总结：原来端口被复用是因为设置了SO_REUSEADDR，当然不止这一点，下面会继续描述

回到源码第一行

NODE_UNIQUE_ID是什么？

下面给出介绍：

function createWorkerProcess(id, env) {  
  // ...  
  workerEnv.NODE_UNIQUE_ID = '' + id;  
  // ...  
  return fork(cluster.settings.exec, cluster.settings.args, {  
    env: workerEnv,  
    silent: cluster.settings.silent,  
    execArgv: execArgv,  
    gid: cluster.settings.gid,  
    uid: cluster.settings.uid  
  });  
}

原来，创建子进程的时候，给了每个进程一个唯一的自增标示ID

随后Node.js在初始化时，会根据该环境变量，来判断该进程是否为cluster模块fork出的工作进程，若是，则执行workerInit()函数来初始化环境，否则执行masterInit()函数

就是这行入口的代码～

module.exports = require(`internal/cluster/${childOrMaster}`);

接下来我们需要看一下net模块的listen函数源码：

// lib/net.js  
// ...  
function listen(self, address, port, addressType, backlog, fd, exclusive) {  
  exclusive = !!exclusive;  
  if (!cluster) cluster = require('cluster');  
  if (cluster.isMaster || exclusive) {  
    self._listen2(address, port, addressType, backlog, fd);  
    return;  
  }  
  cluster._getServer(self, {  
    address: address,  
    port: port,  
    addressType: addressType,  
    fd: fd,  
    flags: 0  
  }, cb);  
  function cb(err, handle) {  
    // ...  
    self._handle = handle;  
    self._listen2(address, port, addressType, backlog, fd);  
  }  
}

仔细一看，原来listen函数会根据是不是主进程做不同的操作！

上面有提到SO_REUSEADDR选项，在主进程调用的_listen2中就有设置。

子进程初始化的每个workerinit函数中，也有cluster._getServer这个方法，

你可能已经猜到，问题一的答案，就在这个cluster._getServer函数的代码中。它主要干了两件事：

向master进程注册该worker，若master进程是第一次接收到监听此端口/描述符下的worker，则起一个内部TCP服务器，来承担监听该端口/描述符的职责，随后在master中记录下该worker。
Hack掉worker进程中的net.Server实例的listen方法里监听端口/描述符的部分，使其不再承担该职责。

对于第一件事，由于master在接收，传递请求给worker时，会符合一定的负载均衡规则（在非Windows平台下默认为轮询），这些逻辑被封装在RoundRobinHandle类中。故，初始化内部TCP服务器等操作也在此处：

// lib/cluster.js  
// ...  
function RoundRobinHandle(key, address, port, addressType, backlog, fd) {  
  // ...  
  this.handles = [];  
  this.handle = null;  
  this.server = net.createServer(assert.fail);  
  if (fd >= 0)  
    this.server.listen({ fd: fd });  
  else if (port >= 0)  
    this.server.listen(port, address);  
  else  
    this.server.listen(address);  // UNIX socket path.  
  /// ...  
}

在子进程中：

function listen(backlog) {  
    return 0;  
  }  
  function close() {  
    // ...  
  }  
  function ref() {}  
  function unref() {}  
  var handle = {  
    close: close,  
    listen: listen,  
    ref: ref,  
    unref: unref,  
  }

由于net.Server实例的listen方法，最终会调用自身_handle属性下listen方法来完成监听动作，故在代码中修改之：此时的listen方法已经被hack ，每次调用只能发挥return 0 ,并不会监听端口

// lib/net.js  
// ...  
function listen(self, address, port, addressType, backlog, fd, exclusive) {  
  // ...  
  if (cluster.isMaster || exclusive) {  
    self._listen2(address, port, addressType, backlog, fd);  
    return; // 仅在worker环境下改变  
  }  
  cluster._getServer(self, {  
    address: address,  
    port: port, 
     addressType: addressType,  
    fd: fd,  
    flags: 0  
  }, cb);  
  function cb(err, handle) {  
    // ...  
    self._handle = handle;  
    // ...  
  }  
}

这里可以看到，传入的回调函数中的handle，已经把listen方法重新定义，返回0，那么等子进程调用listen方法时候，也是返回0，并不会去监听端口，至此，焕然大悟，原来是这样，真正监听端口的始终只有主进程!

上面通过将近3000字讲解，把端口复用这个问题讲清楚了，下面把负载均衡这块也讲清楚。然后再讲PM2的原理实现,其实不过是对cluster模式进行了封装，多了很多功能而已～

首先画了一个流程图

核心实现源码：

function RoundRobinHandle(key, address, port, addressType, backlog, fd) {  
  // ...  
  this.server = net.createServer(assert.fail);  
  // ...  
  var self = this;  
  this.server.once('listening', function() {  
    // ...  
    selfself.handle.onconnection = self.distribute.bind(self);  
  });  
}  
RoundRobinHandle.prototype.distribute = function(err, handle) {  
  this.handles.push(handle);  
  var worker = this.free.shift();  
  if (worker) this.handoff(worker);  
};  
RoundRobinHandle.prototype.handoff = function(worker) {  
  // ...  
  var message = { act: 'newconn', key: this.key };  
  var self = this;  
  sendHelper(worker.process, message, handle, function(reply) {  
    // ...  
  });

解析

定义好handle对象中的onconnection方法

触发事件时，取出一个子进程通知，传入句柄

子进程接受到消息和句柄后，做相应的业务处理：

 var accepted = server !== undefined;  
  // ...  
  if (accepted) server.onconnection(0, handle);// lib/cluster.js  
// ...  
// 该方法会在Node.js初始化时由 src/node.js 调用  
cluster._setupWorker = function() {  
  // ...  
  process.on('internalMessage', internal(worker, onmessage));    
  // ...  
  function onmessage(message, handle) {  
    if (message.act === 'newconn')  
      onconnection(message, handle);  
    // ...  
  }  
};  
function onconnection(message, handle) {  
  // ...  
}

总结下来，负载均衡大概流程：

1.所有请求先同一经过内部TCP服务器，真正监听端口的只有主进程。

2.在内部TCP服务器的请求处理逻辑中，有负载均衡地挑选出一个worker进程，将其发送一个newconn内部消息，随消息发送客户端句柄。

3.Worker进程接收到此内部消息，根据客户端句柄创建net.Socket实例，执行具体业务逻辑，返回。

至此，Cluster多进程模式，负载均衡讲解完毕，下面讲PM2的实现原理，它是基于Cluster模式的封装

PM2的使用:

npm i pm2 -g   
pm2 start app.js   
pm2 ls

这样就可以启动你的Node.js服务，并且根据你的电脑CPU个数去启动相应的进程数，监听到错误事件，自带重启子进程，即使更新了代码，需要热更新，也会逐个替换，号称永动机。

它的功能：

1.内建负载均衡（使用Node cluster 集群模块）

2.后台运行

3.0秒停机重载，我理解大概意思是维护升级的时候不需要停机.

4.具有Ubuntu和CentOS 的启动脚本

5.停止不稳定的进程（避免无限循环）

6.控制台检测

7.提供 HTTP API

8.远程控制和实时的接口API ( Nodejs 模块,允许和PM2进程管理器交互 )

先来一张PM2的架构图：

pm2包括 Satan进程、God Deamon守护进程、进程间的远程调用rpc、cluster等几个概念

如果不知道点西方文化，还真搞不清他的文件名为啥是 Satan 和 God：

撒旦（Satan），主要指《圣经》中的堕天使（也称堕天使撒旦），被看作与上帝的力量相对的邪恶、黑暗之源，是God的对立面。

1.Satan.js提供了程序的退出、杀死等方法，因此它是魔鬼；God.js 负责维护进程的正常运行，当有异常退出时能保证重启，所以它是上帝。作者这么命名，我只能说一句：oh my god。

God进程启动后一直运行，它相当于cluster中的Master进程，守护者worker进程的正常运行。

2.rpc（Remote Procedure Call Protocol）是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。同一机器不同进程间的方法调用也属于rpc的作用范畴。

3.代码中采用了axon-rpc 和 axon 两个库，基本原理是提供服务的server绑定到一个域名和端口下，调用服务的client连接端口实现rpc连接。后续新版本采用了pm2-axon-rpc 和 pm2-axon两个库，绑定的方法也由端口变成.sock文件，因为采用port可能会和现有进程的端口产生冲突。

执行流程

程序的执行流程图如下：

每次命令行的输入都会执行一次satan程序。如果God进程不在运行，首先需要启动God进程。然后根据指令，satan通过rpc调用God中对应的方法执行相应的逻辑。

以 pm2 start app.js -i 4为例，God在初次执行时会配置cluster，同时监听cluster中的事件：

// 配置cluster  
cluster.setupMaster({  
  exec : path.resolve(path.dirname(module.filename), 'ProcessContainer.js')  
});  
// 监听cluster事件  
(function initEngine() {  
  cluster.on('online', function(clu) {  
    // worker进程在执行  
    God.clusters_db[clu.pm_id].status = 'online';  
  });  
  // 命令行中 kill pid 会触发exit事件，process.kill不会触发exit  
  cluster.on('exit', function(clu, code, signal) {  
    // 重启进程 如果重启次数过于频繁直接标注为stopped  
    God.clusters_db[clu.pm_id].status = 'starting';  
    // 逻辑  
    ...  
  });  
})();

在God启动后，会建立Satan和God的rpc链接，然后调用prepare方法。prepare方法会调用cluster.fork，完成集群的启动

God.prepare = function(opts, cb) {  
  ...  
  return execute(opts, cb);  
}; 
 function execute(env, cb) {  
  ...  
  var clu = cluster.fork(env);  
  ...  
  God.clusters_db[id] = clu;  
  clu.once('online', function() {  
    God.clusters_db[id].status = 'online';  
    if (cb) return cb(null, clu);  
    return true;  
  });  
  return clu;  
}

PM2的功能目前已经特别多了，源码阅读非常耗时，但是可以猜测到一些功能的实现：

例如

如何检测子进程是否处于正常活跃状态？

采用心跳检测

每隔数秒向子进程发送心跳包，子进程如果不回复，那么调用kill杀死这个进程  
然后再重新cluster.fork()一个新的进程

子进程发出异常报错，如何保证一直有一定数量子进程？

子进程可以监听到错误事件，这时候可以发送消息给主进程，请求杀死自己  
并且主进程此时重新调用cluster.fork一个新的子进程

目前不少Node.js的服务，依赖Nginx+pm2+docker来实现自动化+监控部署，

pm2本身也是有监听系统的，分免费版和收费版～

具体可以看官网，以及搜索一些操作手册等进行监控操作，配置起来比较简单，

这里就不做概述了。

https://pm2.keymetrics.io/

如果感觉写得不错，麻烦帮忙点个赞然后分享给你身边多人，原创不易，需要支持～！