Libérer le traitement parallèle avec les threads de travail Node.js

Les Worker Threads permettent un véritable parallélisme dans Node.js, parfait pour les tâches gourmandes en CPU. Allons-y.

Pourquoi les threads de travail ?

1. Exécution parallèle du code JavaScript
2. Capacités de mémoire partagée
3. Idéal pour les opérations liées au processeur

Utilisation de base

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

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', (msg) => console.log('From worker:', msg));
  worker.postMessage('Hello, Worker!');
} else {
  parentPort.on('message', (msg) => {
    console.log('From main:', msg);
    parentPort.postMessage('Hello, Main!');
  });
}

Transmission de données

1. Algorithme de clonage structuré (par défaut)
2. Objets transférables
3. SharedArrayBuffer pour les transferts sans copie

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

const worker = new Worker('./worker.js');

const sharedBuffer = new SharedArrayBuffer(4);
const arr = new Int32Array(sharedBuffer);
arr[0] = 123;

worker.postMessage({ sharedBuffer });

Pools de travailleurs

const { StaticPool } = require('node-worker-threads-pool');

const pool = new StaticPool({
  size: 4,
  task: (n) => n * 2
});

async function runTasks() {
  const results = await Promise.all([
    pool.exec(10),
    pool.exec(20),
    pool.exec(30)
  ]);
  console.log(results); // [20, 40, 60]
}

runTasks().catch(console.error);

Meilleures pratiques

1. Utiliser pour les tâches gourmandes en CPU, pas les opérations d'E/S
2. Mettre en œuvre une gestion appropriée des erreurs
3. Gérez soigneusement les ressources partagées pour éviter les conditions de concurrence
4. Envisagez d'utiliser des pools de travailleurs pour une meilleure gestion des ressources

Considérations relatives aux performances

1. La création de fils de discussion entraîne des frais généraux ; réutiliser les travailleurs lorsque cela est possible
2. Équilibrer le nombre de nœuds de calcul avec les cœurs de processeur disponibles
3. Minimiser le transfert de données entre les threads

Les pièges à éviter

1. Utilisation excessive pour des tâches simples (le threading entraîne une surcharge)
2. Négliger de licencier les travailleurs une fois terminé
3. En supposant un équilibrage de charge automatique (vous devez gérer cela)

Les Worker Threads brillent pour le traitement parallèle des tâches gourmandes en CPU. Utilisez-le judicieusement pour booster vos applications Node.js.

Bravo ?

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!