node.js之多进程

冷不防 2023-10-10 09:19 28阅读 0赞

## 介绍 ##

NodeJS的JavaScript运行在单个进程的单个线程上，一个JavaScript执行进程只能利用一个CPU核心，

而如今大多数CPU均为多核CPU，为了充分利用CPU资源，Node提供了child\_process和cluster模块来实现多进程以及进程管理。

我们这里将根据Master-Worker模式，搭建一个简单的服务器集群来充分利用多核CPU资源，探索进程间通信、负载均衡等知识。

> 下图是Master-Worker模式，进程分为master进程和worker进程，master进程负责调度或管理worker进程，worker进程则负责具体的业务处理。

> 在服务器层面，worker可以是一个服务进程，负责处理来自客户端的请求，多个worker便相当于多个服务器，从而构成一个服务器集群。

> master则是负责创建worker，将来自客户端的请求分配到各个服务器上去处理，并监控worker的运行状态以及进行管理等操作。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70]

### child\_process ###

#### 1.创建子进程 ####

child\_process模块提供了spawn()、exec()、execFile()、fork()这4个方法用于创建子进程，

我们这里使用fork()方法来创建子进程，fork()方法只需指定要执行的JavaScript文件模块，即可创建Node的子进程。

下面是简单的HelloWorld示例，master进程根据CPU数量创建出相应数量的worker进程，worker进程中利用进程ID来标记自己。

以下是master进程代码，文件名为master.js。

const childProcess = require('child_process')
    
    const cpuNum = require('os').cpus().length
    
    for (let i = 0; i < cpuNum; ++i) {
    
      childProcess.fork('./worker.js')
    }
    
    console.log('Master: Hello world.')

以下是worker进程的代码，文件名为worker.js。

console.log('Worker-' + process.pid + ': Hello world.')

执行node master.js，得到如下结果，master创建4个worker后输出HelloWorld信息，每个worker也分别输出自己的HelloWorld信息。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 1]

#### 2.父子进程间的通信 ####

创建worker之后，接下来实现master和worker之间的通信。

Node父子进程之间可以通过on(‘message’)和send()来实现通信，on(‘message’)其实是监听message事件，

当该进程收到其他进程发送的消息时，便会触发message事件。send()方法则是用于向其他进程发送信息

master进程中调用child\_process的fork()方法后会得到一个子进程的实例，通过这个实例可以监听来自子进程的消息或者向子进程发送消息。

worker进程则通过process对象接口监听来自父进程的消息或者向父进程发送消息。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 2]

> 下面是简单示例，master创建worker之后，向worker发送信息，worker在收到master的信息后将信息输出，并回复master。master收到回复后输出信息。

在子进程中：

通过process.on(‘message’)和process.send()的机制来接收和发送消息。

在父进程中：

通过child.on(‘message’)和process.send()的机制来接收和发送消息。

以下是master进程代码，文件名为master.js。

const childProcess = require('child_process')
    
    const worker = childProcess.fork('./worker.js')
    
    worker.send('Hello world.')
    
    worker.on('message', (msg) => {
    
      console.log('[Master] Received message from worker: ' + msg)
    })

以下是worker进程的代码，文件名为worker.js。

process.on('message', (msg) => {
    
      console.log('[Worker] Received message from master: ' + msg)
      
      process.send('Hi master.')
    })

执行node master.js，结果如下，master和worker可以正常通信。

![在这里插入图片描述][201909241518143.png]

#### 3.Master分发请求给Worker处理 ####

进程通信时使用到的send()方法，除了发送普通的对象之外，还可以用于发送句柄。

句柄是一种引用，可以用来标识资源，例如通过句柄可以标识一个socket对象、一个server对象等。

利用句柄传递，可以实现请求的分发。master进程创建一个TCP服务器监听特定端口，

收到客户端的请求后，会得到一个socket对象，通过这个socket对象可以跟客户端进行通信从而处理客户端的请求。

master进程可以通过句柄传递将该socket对象发送给worker进程，让worker进程去处理请求。

该模式的结构图如下，在master上还可以通过特定的算法实现负载均衡，将客户端的请求均衡地分发给worker去处理。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 3]

> 下面是一个简单示例。master创建TCP服务器并监听8080端口，收到请求后将请求分发给worker处理。worker收到master发来的socket以后，通过socket对客户端进行响应。为方便看到请求的处理情况，worker给出的响应内容会说明该请求是被哪个worker处理。

以下是master进程代码，文件名为master.js。

const childProcess = require('child_process')
    
    const net = require('net')
    
    const cpuNum = require('os').cpus().length
    
    // 创建工作进程
    let workers = []
    
    let cur = 0
    
    for (let i = 0; i < cpuNum; ++i) {
    
      workers.push(childProcess.fork('./worker.js'))
      
      console.log('Create worker-' + workers[i].pid)
    }
    
    // 创建TCP服务器
    const server = net.createServer()
    
    // 服务器收到请求后分发给工作进程去处理
    
    // 通过轮转方式实现工作进程的负载均衡
    server.on('connection', (socket) => {
    
      workers[cur].send('socket', socket)
      
      cur = Number.parseInt((cur + 1) % cpuNum)
    })
    
    server.listen(8080, () => {
    
      console.log('TCP server: 127.0.0.1:8080')
    })

以下是worker进程的代码，文件名为worker.js。

process.on('message', (msg, socket) => {
    
      if (msg === 'socket' && socket) {
      
        // 利用setTimeout模拟处理请求时的操作耗时
        
        setTimeout(() => {
        
          socket.end('Request handled by worker-' + process.pid)
        }, 10)
      }
    })

> 为了访问TCP服务器进行实验，这里需要写一个简单的TCP客户端，代码如下。该客户端会创建10个TCP连接，得到服务器响应之后将响应的内容进行输出。

以下是TCP客户端代码，文件名为tcp\_client.js。

const net = require('net')
    const maxConnectCount = 10
    
    for (let i = 0; i < maxConnectCount; ++i) {
      net.createConnection({
        port: 8080,
        host: '127.0.0.1'
      }).on('data', (data) => {
        console.log(data.toString())
      })
    }

先执行node master.js启动服务器，然后执行node tcp\_client.js启动客户端。得到的结果如下，10个请求被分发到不同服务器上进行处理，并且可以看到master中的轮转分发请求起到了作用，实现了简单的负载均衡。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 5]

#### 4.Worker监听同一个端口 ####

前面说过，sned()方法可以传递句柄，通过传递句柄，我们除了发送socket对象之外，还可以直接发送一个server对象。我们可以在master进程中创建一个TCP服务器，将服务器对象直接发送给worker进程，让worker去监听端口并处理请求。这样的话，master和worker进程都会监听相同端口，当客户端发起请求时，请求可能被master接收，也可能被worker接收。而master不负责处理业务，如果请求被master接收到，由于master上没有处理业务的逻辑，请求将无法得到处理。因此可以实现为如下图所示的模式，master将TCP服务器发送给worker使得所有worker监听同一个端口以后，master关闭对端口的监听。这样便只有worker在监听同一端口，请求将会都被worker进行处理，与master无关。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 6]

> 这种模式下，多个进程监听相同端口，当网络请求到来时，会进行抢占式调度，只有一个进程会抢到连接然后进行服务。因此，可以确保每个请求都会被特定的worker处理，而不是一个请求同时被多个worker处理。但由于是抢占式的调度，不能够保证每个worker的负载均衡。可能由于处理不同业务时CPU和IO繁忙度的不同导致进程抢到的请求数量不同，形成负载不均衡的情况

以下是master进程代码，文件名为master.js。

以下是worker进程的代码，文件名为worker.js。

process.on('message', (msg, server) => {
      if (msg === 'server' && server) {
        server.on('connection', (socket) => {
          // 利用setTimeout模拟处理请求时的操作耗时
          setTimeout(() => {
            socket.end('Request handled by worker-' + process.pid)
          }, 10)
        })
      }
    })

继续使用之前的tcp\_client来进行实验，先执行node master.js启动服务器，然后执行node tcp\_client.js启动客户端。得到结果如下，请求可以被不同的worker进程处理，但由于worker进程是抢占式地为请求进行服务，所以不一定能实现每个worker的负载均衡。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 8]  
? 推荐连接：

*  [深入解析child\_process模块和cluster模块][child_process_cluster]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190924151713343.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190924151732428.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190924151745978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[201909241518143.png]: https://img-blog.csdnimg.cn/201909241518143.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190924151828186.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20190924151851340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20190924151900520.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20190924151915142.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20190924151938614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20190924151953768.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NjMzNw==,size_16,color_FFFFFF,t_70
[child_process_cluster]: https://segmentfault.com/a/1190000016169207