Comment implémenter le multithreading nodejs

Node.js est actuellement l'un des langages de programmation back-end les plus populaires. Ses fonctionnalités d'E/S basées sur les événements et non bloquantes le rendent plus efficace que les autres langages.

En particulier lorsqu'il s'agit d'atteindre une concurrence élevée, les avantages des E/S événementielles et non bloquantes de Node.js sont particulièrement importants, ce qui peut fournir une méthode d'exécution plus efficace pour nos programmes.

Mais dans certains cas, le mode d'exécution monothread peut en fait devenir un goulot d'étranglement insurmontable, comme lors du traitement de tâches gourmandes en CPU, bien que Node.js ait adopté un modèle d'E/S asynchrone non bloquant pour résoudre les E/S. problèmes intensifs et réduire la complexité du code. Cependant, lorsque vous utilisez des bibliothèques multitâches comme MPI, vous devez toujours implémenter une solution multithread. Cependant, le modèle monothread de Node.js ne prend pas en charge le multithreading, d'autres méthodes doivent donc être utilisées pour implémenter des solutions multithread.

Dans cet article, nous présenterons quelques solutions qui peuvent être utilisées pour implémenter le multi-threading dans Node.js, et dans quelles circonstances elles sont les plus efficaces.

1. Child Process

Le module Child Process de Node.js fournit un moyen de créer des processus enfants et d'implémenter des solutions multithread via des processus enfants. Chaque processus enfant peut s'exécuter dans son propre thread, évitant ainsi le problème de blocage dans le processus principal.

En utilisant le module Child Process, nous pouvons effectuer certaines tâches gourmandes en CPU dans le processus enfant et choisir différentes stratégies pour l'allocation des tâches et l'interaction des données. Voici un exemple d'utilisation de Child Process pour implémenter l'ajout multithread :

const { fork } = require('child_process');

// 创建子进程
const worker = fork('./worker');

// 向子进程发送数据
worker.send({a: 1, b: 2});

// 接收来自子进程的数据
worker.on('message', result => {
  console.log(result);
})

// 错误处理
worker.on('error', err => {
  console.log(err);
})

Dans cet exemple, nous utilisons d'abord le module Child Process pour créer un processus enfant, puis envoyons des données au processus enfant via le worker.send( ) Le processus enfant Après avoir effectué le calcul, le résultat est renvoyé au processus principal et la valeur de retour est reçue via la méthode worker.on('message'). Cela permet des calculs multithreads.

2. Worker Threads

Node.js fournit une autre façon d'implémenter le multi-threading : Worker Threads, qui nous permet de démarrer un sous-thread indépendant du thread principal. Ce sous-thread peut effectuer certaines tâches fastidieuses, évite ainsi le problème du blocage du thread principal dans un modèle monothread.

Contrairement aux processus enfants, les Worker Threads partagent entièrement la mémoire. Ils peuvent exécuter du code JavaScript dans un environnement indépendant sans se soucier du partage de données.

Ce qui suit est un exemple d'utilisation de Worker Threads pour implémenter des opérations d'addition multithread :

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

function runService() {
  // 创建 Worker 线程
  const worker = new Worker(`
    const add = (a, b) => a + b;
    const { parentPort } = require('worker_threads');

    // 接收来自主线程的数据
    parentPort.on('message', message => {
      // 子线程执行加法运算
      const result = add(message.a, message.b);

      // 将结果发送给主线程
      parentPort.postMessage(result);
    });
  `);

  return worker;
}

// 启动 Worker 线程
const worker = runService();

// 向 Worker 线程发送数据
worker.postMessage({ a: 1, b: 2 });

// 接收来自 Worker 线程的数据
worker.on('message', result => {
  console.log(result);
});

// 错误处理
worker.on('error', err => {
  console.log(err);
});

Ici, nous utilisons Worker Threads pour créer un environnement de sous-thread indépendant dans lequel notre logique de calcul est exécutée. Envoyez des données au thread enfant via la méthode Worker.postMessage() et recevez les résultats de calcul renvoyés par le thread enfant via la méthode Worker.on('message'). De cette façon, nous réalisons un calcul multithread.

3. Cluster

Une autre solution pour implémenter le multi-threading dans Node.js consiste à utiliser le module Cluster de Node.js. Le module Cluster réalise l'équilibrage de charge en répartissant les connexions entre plusieurs processus. En d'autres termes, l'utilisation de plusieurs processus peut améliorer considérablement les performances du système lors du traitement de tâches chronophages.

Dans certains cas, le module Cluster peut être plus adapté à la gestion des problèmes de parallélisme des données que Child Process et Worker Threads. Pour utiliser le module Cluster, vous devez suivre les étapes suivantes :

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

if (cluster.isMaster) {
  // 获取 CPU 的核心数
  const numCPUs = require('os').cpus().length;

  // fork 子进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 处理 worker exit 事件
  cluster.on('exit', (worker, code, signal) => {
    console.info(`Worker ${worker.process.pid} died`);
  });
} else {
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`hello world from ${process.pid}`);
  });

  server.listen(8000, () => {
    console.info(`Server running at http://localhost:8000/ in worker process with pid ${process.pid}`);
  });
}

Dans cet exemple, nous déterminons d'abord s'il s'agit du processus principal. Si tel est le cas, forkons plusieurs processus enfants et écoutons les événements de sortie de chaque processus enfant afin que cela soit possible. le processus principal peut être averti lorsqu'une erreur se produit. Sinon, un service HTTP est créé dans le processus enfant et le pid du processus enfant actuel est spécifié par le paramètre passé dans la méthode d'écoute.

Résumé

Voici les trois principales solutions pour implémenter le multi-threading dans Node.js, Child Process, Worker Threads et Cluster. Les deux premières sont plus adaptées au traitement de tâches gourmandes en CPU, tandis que la seconde est plus adaptée. traitement des connexions réseau. Utilisé lors de l'exécution de tâches d'aspect et de la mise en œuvre de l'équilibrage de charge. Bien entendu, il existe d'autres solutions, comme utiliser des Web Workers ou utiliser des bibliothèques C++ de niveau inférieur pour implémenter le multi-threading, etc.

Lorsque vous utilisez les solutions ci-dessus, vous devez faire attention à certains détails, tels que l'exactitude des données et les problèmes de mémoire partagée, etc., mais avec l'aide de ces solutions, nous pouvons également fournir des capacités de traitement efficaces et évolutives pour Node Applications .js. Obtenez de meilleures performances.

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!