Analyser en détail l'utilisation du module de cluster Node.js

Cette fois, je vais vous apporter une analyse du module cluster Node.js Quelles sont les précautions pour l'explication détaillée de l'utilisation du module cluster Node.js. Ce qui suit est un cas pratique, jetons un coup d'œil ensemble.

Présentation du module de cluster

Les instances de nœuds sont des opérations à thread unique. Dans la programmation côté serveur, plusieurs instances de nœuds sont généralement créées pour gérer les demandes des clients afin d'améliorer le débit du système. Pour de telles instances à nœuds multiples, nous appelons cela un cluster.

Avec le module cluster de node, les développeurs peuvent bénéficier des avantages des services de cluster sans presque aucune modification du code original du projet.

Le cluster a les deux solutions d'implémentation communes suivantes, et le module de cluster fourni avec le nœud adopte la deuxième solution.

Option 1 : plusieurs instances de nœuds + plusieurs ports

Les instances de nœuds du cluster écoutent chacune des ports différents, puis le proxy inverse implémente la demande sur plusieurs distributions de ports.

1. Avantages : Implémentation simple, chaque instance est relativement indépendante, ce qui est bon pour la stabilité du service.

2. Inconvénients : occupation portuaire accrue, la communication entre les processus est plus gênante.

Option 2 : Le processus principal transmet la requête au processus enfant

Dans le cluster, créez un processus principal (maître) et plusieurs processus enfants (travailleur). Le maître surveille les demandes de connexion des clients et les transmet aux travailleurs conformément à des politiques spécifiques.

1. Avantages : Généralement, un seul port est occupé, la communication est relativement simple et la stratégie de transfert est plus flexible.

2. Inconvénients : La mise en œuvre est relativement complexe et nécessite une grande stabilité du processus principal.

Exemple de démarrage

Dans le module cluster, le processus principal est appelé maître et le processus enfant est appelé travailleur.

L'exemple est le suivant, créez une instance de serveur avec le même nombre de processeurs pour gérer les requêtes des clients. Notez qu'ils écoutent tous sur le même port.

// server.js
var cluster = require('cluster');
var cpuNums = require('os').cpus().length;
var http = require('http');
if(cluster.isMaster){
 for(var i = 0; i < cpuNums; i++){
  cluster.fork();
 }
}else{
 http.createServer(function(req, res){
  res.end(`response from worker ${process.pid}`);
 }).listen(3000);
 console.log(`Worker ${process.pid} started`);
}

Créer un script batch : ./req.sh.

#!/bin/bash
# req.sh
for((i=1;i<=4;i++)); do  
 curl http://127.0.0.1:3000
 echo ""
done

Le résultat est le suivant. Comme vous pouvez le constater, les réponses proviennent de différents processus.

réponse du travailleur 23735
réponse du travailleur 23731
réponse du travailleur 23729
réponse du travailleur 23730

cluster Principe de mise en œuvre du module

Pour comprendre le module cluster, nous devons principalement comprendre trois questions :

1. Comment le maître et les ouvriers communiquent-ils ?

2. Comment réaliser le partage de port pour plusieurs instances de serveur ?

3. Instances de serveur multiples, comment distribuer les requêtes des clients à plusieurs travailleurs ?

Ce qui suit sera introduit sur la base du diagramme schématique. Pour l'introduction au niveau du code source, vous pouvez vous référer au github de l'auteur.

Question 1 : Comment le maître et l'ouvrier communiquent

Cette question est relativement simple. Le processus maître crée des processus de travail via cluster.fork(). Cluster.fork() crée en interne des processus enfants via child_process.fork().

En d'autres termes :

1. Le processus maître et le processus travailleur sont la relation entre les processus parent et enfant.

2. Le processus maître et le processus travailleur peuvent communiquer via le canal IPC. (Important)

Question 2 : Comment implémenter le partage de port

Dans l'exemple précédent, les serveurs créés dans plusieurs wokers écoutaient le même port .port 3000. De manière générale, si plusieurs processus écoutent le même port, le système signalera une erreur.

Pourquoi notre exemple est-il correct ?

Le secret est que la méthode Listen() est spécialement traitée dans le module net. Selon que le processus courant est un processus maître ou un processus travailleur :

1. processus maître : écoute les requêtes normalement sur ce port. (Aucun traitement particulier)

2. worker进程：创建server实例。然后通过IPC通道，向master进程发送消息，让master进程也创建 server 实例，并在该端口上监听请求。当请求进来时，master进程将请求转发给worker进程的server实例。

归纳起来，就是：master进程监听特定端口，并将客户请求转发给worker进程。

如下图所示：

问题3：如何将请求分发到多个worker

每当worker进程创建server实例来监听请求，都会通过IPC通道，在master上进行注册。当客户端请求到达，master会负责将请求转发给对应的worker。

具体转发给哪个worker？这是由转发策略决定的。可以通过环境变量NODE_CLUSTER_SCHED_POLICY设置，也可以在cluster.setupMaster(options)时传入。

默认的转发策略是轮询（SCHED_RR）。

当有客户请求到达，master会轮询一遍worker列表，找到第一个空闲的worker，然后将该请求转发给该worker。

master、worker内部通信小技巧

在开发过程中，我们会通过 process.on('message', fn) 来实现进程间通信。

前面提到，master进程、worker进程在server实例的创建过程中，也是通过IPC通道进行通信的。那会不会对我们的开发造成干扰呢？比如，收到一堆其实并不需要关心的消息？

答案肯定是不会？那么是怎么做到的呢？

当发送的消息包含cmd字段，且改字段以NODE_作为前缀，则该消息会被视为内部保留的消息，不会通过message事件抛出，但可以通过监听'internalMessage'捕获。

以worker进程通知master进程创建server实例为例子。worker伪代码如下：

// woker进程
const message = {
 cmd: 'NODE_CLUSTER',
 act: 'queryServer'
};
process.send(message);

master伪代码如下：

worker.process.on('internalMessage', fn);

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

设计模式的策略模式怎样在前端中使用

如何对微信小程序进行开发

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!