Introduction au module cluster dans Node.js-js tutoriel-php.cn

Introduction au module cluster dans Node.js

不言

Libérer： 2018-07-04 11:20:27

original

1240 Les gens l'ont consulté

Cet article présente principalement l'introduction du module cluster dans Node.js. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

La conception monothread de Node est. n'est plus disponible. Afin de « réduire » complètement les performances de la machine, Node a ajouté un cluster de modules intégré, qui peut implémenter des fonctions de cluster en gérant un tas de processus enfants via un processus parent. Cet article présente principalement une analyse approfondie. du module de cluster Node.js, les amis intéressés peuvent se référer à la

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.

Avantages : Implémentation simple, chaque instance est relativement indépendante, ce qui est bon pour la stabilité du service.
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.

Avantages : Généralement, un seul port est occupé, la communication est relativement simple et la stratégie de transfert est plus flexible.
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(&#39;cluster&#39;);
var cpuNums = require(&#39;os&#39;).cpus().length;
var http = require(&#39;http&#39;);

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`);
}

Copier après la connexion

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

Copier après la connexion

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 :

Comment le maître et les ouvriers communiquent-ils ?
Comment réaliser le partage de port pour plusieurs instances de serveur ?
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 communiquer entre maître et ouvrier

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 :

Le processus maître et le processus travailleur sont la relation entre les processus parent et enfant.
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 :

processus maître : écoute les requêtes normalement sur ce port. (Aucun traitement spécial)
Processus de travail : Créer une instance de serveur. Envoyez ensuite un message au processus maître via le canal IPC, afin que le processus maître crée également une instance de serveur et écoute les requêtes sur ce port. Lorsqu'une requête arrive, le processus maître la transmet à l'instance de serveur du processus de travail.

Pour résumer, le processus maître écoute un port spécifique et transmet les demandes des clients au processus de travail.

Comme indiqué ci-dessous :

Question 3 : Comment distribuer les demandes à plusieurs travailleurs

Chacun lorsque le Le processus de travail crée une instance de serveur pour écouter les demandes, elle sera enregistrée sur le maître via le canal IPC. Lorsqu'une demande d'un client arrive, le maître sera responsable de transmettre la demande au travailleur correspondant.

À quel travailleur sera-t-il transmis spécifiquement ? Ceci est déterminé par la stratégie de transfert. Il peut être défini via la variable d'environnement NODE_CLUSTER_SCHED_POLICY ou transmis lorsque 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: &#39;NODE_CLUSTER&#39;,
 act: &#39;queryServer&#39;
};
process.send(message);

Copier après la connexion

master伪代码如下：

worker.process.on(&#39;internalMessage&#39;, fn);

Copier après la connexion