Comment implémenter le multi-threading dans nodejs

Bien que Node.js soit monothread, il peut simuler le multithread de plusieurs manières : 1. Thread de travail : créer des threads indépendamment pour effectuer des tâches ; 2. Module de cluster : créer plusieurs processus de travail pour un traitement parallèle ; : planifier des tâches dans la boucle d'événements, exécution non bloquante.

Comment implémenter le multi-threading dans Node.js ?

Node.js est un environnement d'exécution à thread unique, ce qui signifie qu'il ne peut gérer qu'une seule tâche à la fois. Cependant, le multi-threading peut être simulé par :

1. Worker Threads

Node.js 10.5 et versions ultérieures ont introduit les Worker threads, qui permettent la création de threads indépendants pour effectuer des tâches chronophages, libérant ainsi le thread principal. . Les threads de travail présentent les avantages suivants :

• Isolés du thread principal et ne bloquent donc pas le thread principal.
• Peut communiquer avec le fil principal via des canaux.
• Utilisez la mémoire partagée par défaut, ce qui peut améliorer les performances.

2. Module Cluster

Le module Cluster permet la création de plusieurs processus de travail, chacun avec sa propre boucle d'événements. Le processus principal est responsable de l'attribution des tâches aux processus de travail, et les processus de travail sont responsables du traitement des tâches. Le module Cluster présente les avantages suivants :

• Exécuter des tâches en parallèle sur tous les processus.
• Amélioration de l'évolutivité et du débit.
• Peut redémarrer automatiquement les processus de travail ayant échoué.

3. Boucle d'événements

Le fonctionnement de Node.js est basé sur la boucle d'événements, qui est une boucle exécutée en continu qui vérifie en permanence s'il y a des tâches en attente. Les tâches peuvent être des opérations d'E/S, des minuteries ou du code utilisateur. L'exécution non bloquante est obtenue en planifiant des tâches fastidieuses dans la boucle d'événements, libérant ainsi le thread principal.

Implémentation spécifique

Utiliser le fil de travail :

<code class="js">// 创建一个 worker 线程
const worker = new Worker('./worker.js');

// 监听 worker 线程的消息
worker.addEventListener('message', (event) => {
  console.log('Received message from worker:', event.data);
});

// 向 worker 线程发送消息
worker.postMessage({ message: 'Hello from main thread!' });</code>

Utiliser le module Cluster :

<code class="js">// 创建一个 cluster 监听器
const cluster = require('cluster');

// 如果是主进程，则创建 worker 进程
if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  // 如果是 worker 进程，则执行任务
  console.log(`Worker ${cluster.worker.id} started`);
  performTask();
}</code>

Utiliser la boucle d'événement :

<code class="js">// 安排一个耗时任务到事件循环
setTimeout(() => {
  console.log('耗时任务完成');
}, 1000);</code>

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!