Une brève analyse de Node.js utilisant les multi-threads worker_threads pour le traitement parallèle

Comment utiliser Node.js pour le traitement parallèle ? L'article suivant vous présentera comment utiliser le multi-threading Node pour le traitement parallèle. J'espère qu'il vous sera utile !

Beaucoup de gens ne semblent pas comprendre comment NodeJS monothread peut rivaliser avec les backends multithread.

Pour découvrir pourquoi, nous devons comprendre la véritable signification du fait que Nodejs soit monothread.

JavaScript lui-même a été créé à l'origine pour faire des choses simples comme valider des formulaires, créer des réponses, etc. Ce n'est qu'en 2009 que le créateur de Node.js, Ryan Dahl, a rendu possible l'écriture de code côté serveur à l'aide de JavaScript.

Les langages côté serveur qui prennent en charge le multithreading ont diverses structures et constructions pour la synchronisation entre les threads et d'autres fonctionnalités orientées thread.

Supporter ces éléments signifie que JavaScript doit changer l'ensemble du langage, ce qui va à l'encontre des idées des créateurs de JavaScript. Ainsi, pour que JavaScript pur prenne en charge le multithreading, Dahl a dû créer une solution de contournement. Jetons un coup d'oeil !

---

Comment fonctionne Node.js ?

Node.js utilise deux types de threads : un thread principal géré par une boucle d'événements et plusieurs threads secondaires dans un pool de threads de travail. Le mécanisme de

Event LoopNode.js pour gérer les opérations d'E/S non bloquantes, même si JavaScript est monothread, décharge les opérations sur le noyau du système lorsque cela est possible. Lorsqu'une opération JavaScript bloque un thread, la boucle d'événements est également bloquée.

Work pool est un modèle d'exécution qui génère et traite des threads séparés, puis exécute les tâches de manière synchrone et renvoie les résultats à la boucle d'événements. La boucle d'événements utilise ensuite ledit résultat pour exécuter le rappel fourni.

Fondamentalement, le pool de tâches gère les opérations d'E/S asynchrones - principalement les interactions avec le disque système et le réseau. Certains modules utilisent des pools de tâches prêts à l'emploi, tels que fs (lourd en E/S) ou crypto (lourd en CPU). Le pool de travailleurs est implémenté dans libuv, ce qui entraîne un délai léger mais presque négligeable lorsque Node doit transférer des données en interne entre JavaScript et C++.

Après avoir compris la signification de la boucle d'événements et du pool de travail, regardons le code suivant :

Dans le code ci-dessus, nous n'avons pas à attendre les événements de manière synchrone. Nous déléguons la tâche de lecture du fichier au pool de travailleurs et appelons la fonction fournie avec le résultat. Étant donné que le pool de nœuds de calcul possède son propre thread, la boucle d'événements peut continuer à s'exécuter normalement pendant la lecture du fichier.

---

Laissez-moi vous présenter : worker_threads

Avec la sortie de Node.js 10.5.0, worker_threads est apparu. Il prend en charge la création d'applications multithread simples en JavaScript

worker_threads est un package de module nodejs. Un thread worker est un morceau de code (généralement extrait d'un fichier) généré dans un thread séparé.

Il est important de noter que les termes thread travailleur, travailleur et fil sont souvent utilisés de manière interchangeable. Ils font tous référence à la même chose.

Les threads de travail dans Node.js sont utiles pour effectuer des tâches JavaScript lourdes. À l'aide de threads, Workers peut facilement exécuter du code JavaScript en parallèle, ce qui le rend plus rapide et plus efficace. Nous pouvons effectuer des tâches lourdes sans perturber le fil conducteur.

Les threads de travail n'ont pas été introduits dans les anciennes versions de Node.js. Alors commencez par mettre à jour votre Node.js pour commencer.

Créez maintenant deux fichiers pour implémenter les threads comme suit :

Nom du fichier : worker.js

const { workerData, parentPort } = require('worker_threads');

console.log(`Write-up on how ${workerData} wants to chill with the big boys`);

parentPort.postMessage({ filename: workerData, status: 'Done' });

Nom du fichier : index.js

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

const runSerice = (workerData) => {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0)
        reject(new Error(`Worker Thread stopped with exit code ${code}`));
    });
  });
};
const run = async () => {
  const result = await runSerice('Tunde Ednut');
  console.log(result);
};

run().catch((err) => console.error(err));

Sortie :

Plus pour les nœuds liés connaissances, veuillez visiter : tutoriel nodejs !

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!