《深入浅出Node.js》进程

Apache是采用多线程/多进程模型实现的；Node与Nginx均是基于事件驱动的。

根据CPU核心数计算要创建的线程/进程数是一个比较合理的方案：

const cpus = require('os').cpus()
console.log(cpus)
> [
    {
      model: 'Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz',
      speed: 2300, // 当前速度
      times: { 
        user: 14576310,  // 用户进程，比如数据库、WEB服务
        nice: 0,         // 用户进程的CPU调度优先级[-20,19]
        sys: 9656410,    // 分配内存、IO操作、创建子进程等
        idle: 85775430,  // 空闲状态时间
        irq: 0           // CPU中断时间，压力均衡
      }
    },
    ...
  ]

Master-Worker模式，又称主从模式

主进程负责管理和调度子进程，子进程处理具体业务。

包child_process可以生成子进程：

• exec 创建一个shell环境（子进程）执行给定的命令
• execFile 创建一个子进程执行 可执行文件（默认无shell环境）
• spawn 创建一个子进程执行给定的命令，可与主进程大量通信
• fork 是特殊的spawn ，专门用来生成NODE子进程，有独立的内存和V8实例（高能耗）

spawn('node', [index.js])
exec('node index.js', (err, stdout, stderr) => {})
execFile('xxx.exe', (err, stdout, stderr) => {})
fork('index.js')

js文件首行添加#! /usr/bin/env node可以直接执行（#! 脚本标识符，/usr/bin/env node 环境变量中去找node来执行）

多进程监听同一个端口 - 句柄传递 sendHandle

子进程们监听同一个端口会报EADDRINUSE异常（端口被占用），多进程监听同一个端口需要借助句柄传递实现。

句柄：用来标识资源的引用，内部包含指向对象的文件描述符。比如句柄可以用来标识一个服务器端socket对象、一个客户端socket对象、一个UDP套接字、一个管道等。

const cp = require('child_process');
const child1 = cp.fork('child.js');
const child2 = cp.fork('child.js');

const server = require('net').createServer();
server.listen(8888, () => {
  child1.send('tcp-handle', server);
  child2.send('tcp-handle', server);
  server.close();
  console.log('main server close');
});

// child.js
var http = require('http');
var server = http.createServer(function (req, res) {
  console.log('http res', process.pid);
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('子进程 ' + process.pid + ' 回复\n');
});

process.on('message', (cmd, tcp) => {
  if (cmd === 'tcp-handle') {
    tcp.on('connection', (socket) => {
      console.log('connection on', process.pid);
      // 转为了 HTTP 服务
      server.emit('connection', socket); 
      // 不太理解，API 上也没有找到 Class: http.Server 的用法
    });
    // --- OR 纯 socket 服务 ---
    // tcp.on('connection', (socket) => {
    //   socket.end('子进程 ' + process.pid + ' 回复\n');
    // });
  }
});

$ curl 'http://127.0.0.1:8888'
子进程 23287 回复
$ curl 'http://127.0.0.1:8888'
子进程 23286 回复

-- 服务的日志
main server close    -- 主进程的服务已经关闭
connection on 23287  -- 子进程的tcp变量还是能监听到连接事件
http res 23287
connection on 23286
http res 23286

主进程的服务已经关闭，子进程的tcp变量还是能监听到连接事件，说明tcp并不是主进程的server的传递，传递的只是它的句柄（server的资源的引用，包含文件描述符。这里可以理解为对端口/端口监听的引用？）

子进程拿到句柄后，根据类型（共4种），用句柄还原一个服务。所以在主进程的服务关闭后，子进程的tcp依然可以监听到端口上的事件。

多个应用监听相同端口时，文件描述符同一时间只能被某个进程所用。这种监听是抢占式的。

可以传递的句柄有：net.Server（TCP服务，即上头那个）net.Socket、net.Native（C++层面的TCP Socket或IPC管道）、dgram.Socket（UDP Socket）、dgram.Native

稳定性

• 自动重启：一旦有未捕获的异常出现，子进程立即停止接收新的连接；当所有连接断开后，退出进程。主进程在侦听到子进程的exit后，立即启动新的进程服务，以此保证整个集群中总是有进程在为用户服务的。
• 平滑重启：一旦有异常出现，主进程会创建新的工作进程来为用户服务，旧的进程一旦处理完已有连接就自动断开。
• 限量重启：单位时间内规定只能重启多少次，超过限制就触发giveup事件，告知放弃重启工作进程这个重要事件。
• 负载均衡：Node默认采用操作系统的抢占式策略，但是对于Node而言，需要分清的是它的繁忙是由CPU、I/O两个部分构成的，影响抢占的是CPU的繁忙
  • 轮叫调度：分发的策略是在N个工作进程中，每次选择第i = (i + 1) mod n个进程来发送连接。在cluster模块中以cluster.schedulingPolicy = cluster.SCHED_RR 或 export NODE_CLUSTER_SCHED_POLICY = rr
• 状态共享：第三方存储（数据库）、主动通知（一个进程单独处理轮询通知各工作进程）

集群 Cluster

cluster模块就是child_process和net模块的组合应用。cluster启动时，会在内部启动TCP服务器，在cluster.fork()子进程时，将这个TCP服务器端socket的文件描述符发送给工作进程。如果进程是通过cluster.fork()复制出来的，那么它的环境变量里就存在NODE_UNIQUE_ID，如果工作进程中存在listen()侦听网络端口的调用，它将拿到该文件描述符，通过SO_REUSEADDR端口重用，从而实现多个子进程共享端口。

cluster模块，用以解决多核CPU的利用率问题，同时也提供了较完善的API，用以处理进程的健壮性问题。

主进程可用的方法和属性有：

• setupPrimary(setting) 用于修改 fork 的默认行为

  import cluster from 'node:cluster';
  
  cluster.setupPrimary({  // NODE<16 使用 setupMaster
    exec: 'worker.js'
  });
  
  const cpus = require('os').cpus();
  cpus.forEach(() => { cluster.fork(); }); 
  

• fork([env]) 产生一个新的工作进程

• isPrimary 是否为主进程

• isWorker === !isPrimary

• worker 当前工作（子）进程对象的引用 {id, send: function }

事件有：

• fork 复制通知
• online 复制完成，子进程通知主进程上线
• listening 子进程使用了文件描述符（共享了Socket监听）
• disconnect 进程间通道断开后触发
• exit 子进程退出时触发

注意：一旦主进程出现问题，所有子进程将会失去管理。在Node的进程管理之外，还需要用监听进程数量或监听日志的方式确保整个系统的稳定性，即使主进程出错退出，也能及时得到监控警报，使得开发者可以及时处理故障。