Clustering et threads de travail - Node JS

Dans un article précédent "Node JS Internals", nous avons discuté de l'architecture interne de Node JS et avons également expliqué pourquoi nous devrions augmenter la taille du pool de threads pour gérer plusieurs requêtes simultanément. Je vous ai dit que l'évolutivité et les performances ne sont pas liées à la taille du pool de threads.

Pour l'évolutivité et les hautes performances, nous pouvons utiliser le clustering et les threads de travail.

Regroupement

Disons que vous participez à un grand mariage et que des milliers d'invités participent au mariage. Il y a une cuisine et un cuisinier prépare la nourriture pour tous ces invités. Cela semble imprévisible, non ? Vous n'utilisez pas toutes les ressources de la cuisine si vous n'avez qu'un seul cuisinier.

C'est exactement ce qui se passe dans une application Node JS exécutée sur un processeur multicœur lorsqu'un seul cœur est utilisé pour gérer toutes les requêtes. Ainsi, même si notre machine possède la puissance du multicœur, sans clustering, notre application ne fonctionne que sur un seul cœur. Un noyau est responsable de la gestion de tout le travail.

Lorsque plusieurs cuisiniers travaillent dans votre cuisine, c'est le regroupement.

Le clustering est une technique utilisée pour permettre à l'application Node JS unique d'utiliser efficacement plusieurs cœurs de processeur.

Pour implémenter le clustering, vous devez utiliser un module de cluster de Node JS.

const cluster = require('cluster');

En utilisant ce module cluster, vous pouvez créer plusieurs instances de notre application Node JS. Ces instances sont appelées travailleurs. Tous les travailleurs partagent le même port de serveur et gèrent simultanément les demandes entrantes.

Il existe deux types de processus dans l'architecture de cluster.

1.Processus de maîtrise :

Le processus Master est comme le cuisinier principal de la cuisine qui gère les ouvriers. Il initialise l'application, configure l'environnement de clustering et délègue également des tâches aux processus de travail. Il ne traite pas directement les demandes de candidature.

À quoi sert le processus Master ?

• Crée plusieurs processus de travail à l'aide de la méthode cluster.fork(). Il redémarre également les travailleurs s'ils tombent en panne ou quittent le système de manière inattendue.

• Il garantit que les demandes entrantes sont réparties sur tous les processus de travail. Sous Linux, cela est géré par un système d'exploitation, et sous Windows, Node JS lui-même fait office d'équilibreur de charge.

• Il permet la communication entre les travailleurs via IPC (Inter-Process Communication).

2. Processus de travail :

Les processus de travail sont l'instance de l'application Node JS créée par le processus maître. Chaque processus s'exécute indépendamment sur un cœur de processeur distinct et gère les requêtes entrantes.

Les processus de travail ne peuvent pas communiquer directement entre eux, ils communiquent via le maître.

Le processus de travail gère la demande entrante et effectue certaines tâches telles que la requête de base de données, le calcul ou toute logique d'application.

const cluster = require('cluster');

Ici, nous vérifions d'abord qu'il s'agit du processus maître. si oui, cela créera des processus de travail.

Dans notre code, je crée un processus de travail en utilisant cluster.fork().

Mais ce n'est pas une manière idéale de créer un processus de travail.

Supposons que vous créiez 4 processus de travail et que votre système comporte deux cœurs.

Pour résoudre ce problème au lieu de créer des processus de travail codés en dur, recherchez d'abord les cœurs de processeur, puis considérez que les données créent des processus de travail.

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
    cluster.fork();
    cluster.fork();
    cluster.fork();
    cluster.fork();

} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

J'utilise un système dual core, donc la sortie ressemblera à ceci.

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  const numCPUs = os.cpus().length;

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

Maintenant, vous avez une question si vous avez un processeur dual-core, alors pourquoi 4 processus de travail créés ?

C'est parce que le nombre de cœurs logiques est de 4, mon processeur prend en charge l'hyperthreading ou le multi-threading simultané (SMT).

Discussions de travail

Au restaurant, le serveur prend la commande et donne cette commande à une équipe de cuisiniers car cuisiner prend un certain temps. Si le nettoyage de la table ou tout autre travail lié au serveur arrive, le serveur le fait. Lorsque la commande est prête, le cuisinier rend la nourriture au serveur et le serveur sert cette nourriture au client.

Il s'agit du même scénario lié aux threads de travail. Si des tâches coûteuses en termes de calcul, comme le traitement de données à grande échelle, des calculs complexes ou des algorithmes lourds, surviennent, le thread principal délègue cette tâche au thread de travail. Le travailleur effectue cette tâche, pas le fil principal.

*Pourquoi, c'est utile ? *

Nous savons que la boucle d'événements Node JS est monothread et si ce gros travail de calcul est effectué par le thread principal alors la boucle d'événements sera bloquée. Si vous utilisez ces threads de travail, ces tâches lourdes sont confiées aux threads de travail et les threads de travail effectuent ces tâches, pas le thread principal afin que la boucle d'événements ne soit pas bloquée.

Les threads de travail peuvent communiquer avec le thread principal via un système de transmission de messages, et les données peuvent être envoyées entre les threads à l'aide du clonage structuré (copie approfondie).

Maintenant, nous essayons d'imiter le fonctionnement des threads de travail.

main.js (thème principal)

Master 12345 is running
Worker 12346 is running
Worker 12347 is running
Worker 12348 is running
Worker 12349 is running

worker.js (fil de travail)

const { Worker } = require('worker_threads');

function startWorker() {
  const worker = new Worker('./worker.js'); // Create a worker using worker.js

  // Listen for messages from the worker
  worker.on('message', (message) => {
    console.log('Message from worker:', message);
  });

  // Handle errors in the worker
  worker.on('error', (error) => {
    console.error('Worker error:', error);
  });

  // Handle worker exit
  worker.on('exit', (code) => {
    console.log(`Worker exited with code ${code}`);
  });

  // Send a message to the worker
  worker.postMessage({ num: 100 });
}

startWorker();

Si les données contiennent de grandes structures, elles seront profondément clonées et ignorées, ce qui peut entraîner une certaine surcharge de performances.

Fonctionnement du code

• La classe Worker est utilisée pour générer de nouveaux threads.

• Vous pouvez envoyer des données au travailleur en utilisant Worker.postMessage et écouter les messages avec Worker.on('message', callback).

• Dans le thread de travail, parentPort est l'interface principale pour communiquer avec le thread principal.

• Vous pouvez écouter les messages du fil de discussion principal (parentPort.on('message')) et renvoyer des messages en utilisant parentPort.postMessage.

Le résultat sera :

const cluster = require('cluster');

Maintenant, vous avez également une question : pourquoi ne créons-nous pas des centaines de threads de travail ?

Mais la raison est que si vous créez plus de threads que le nombre de cœurs, les threads entreront en compétition pour le temps CPU, ce qui entraînera un changement de contexte, ce qui coûte cher et réduit les performances globales.

Quand devez-vous utiliser le clustering, les threads de travail ou les deux dans Node.js ?

1. Quand utiliser les fils de travail ?

• Tâches liées au processeur :

Les tâches impliquent des calculs lourds, tels que le traitement d'images/vidéos, la compression ou le cryptage de données, l'inférence d'apprentissage automatique, les calculs scientifiques

• La mémoire partagée est requise :

Vous devez partager efficacement les données entre les threads sans les dupliquer.

• Utilisation monocœur :

Si votre application doit évoluer uniquement au sein d'un seul processus mais nécessite toujours du parallélisme pour les tâches gourmandes en CPU.

2.Quand utiliser le clustering ?

• E/S liées :

Les tâches impliquent de gérer un grand nombre de demandes de clients, telles que le Web, les serveurs, les applications de chat et les API. Le clustering permet d'évoluer horizontalement en répartissant les requêtes sur tous les cœurs de processeur.

• Mémoire isolée :

Votre application n'a pas besoin de partager beaucoup de données entre les processus.

• Utilisation multicœur :

Vous souhaitez utiliser tous les cœurs disponibles en générant plusieurs processus Node.js.

3.Quand utiliser à la fois les threads de clustering et de travail ?

• Tâches liées au processeur liées aux E/S :

L'application gère les requêtes HTTP mais décharge les tâches gourmandes en calcul. Exemple : Un serveur Web traite les téléchargements de fichiers et effectue le redimensionnement des images ou le transcodage des vidéos.

• Haute évolutivité :

Vous avez besoin d'un parallélisme au niveau du processus et au niveau du thread pour un débit élevé. Dans un site de commerce électronique, le clustering garantit que plusieurs processus gèrent les demandes entrantes. Les threads de travail traitent des tâches en arrière-plan telles que la génération de recommandations personnalisées.

Merci.

N'hésitez pas à poser la question ou à faire des suggestions.

Si vous avez trouvé cela informatif, aimez-le.

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!