Utiliser les worker threads pour paralléliser Node.js
Node.js repose sur une boucle d’événements qui traite efficacement les opérations d’entrée-sortie : requêtes HTTP, accès aux fichiers, appels réseau ou échanges avec une base de données. Cette architecture asynchrone permet de servir de nombreuses connexions avec un seul processus, sans créer un thread par requête.
Les calculs intensifs posent toutefois un problème différent. Une compression lourde, un traitement d’image, une analyse cryptographique ou une transformation de données volumineuse peut monopoliser le thread principal. Pendant ce temps, la boucle d’événements ne répond plus correctement aux autres tâches.
Le module natif node:worker_threads apporte une solution adaptée aux charges liées au processeur. Il permet d’exécuter du code JavaScript dans des threads distincts, tout en conservant l’environnement Node.js. Le parallélisme devient ainsi exploitable pour les traitements qui ne peuvent pas être accélérés par l’asynchronisme classique.
Cette fonctionnalité demande cependant une conception attentive. La création excessive de workers, les échanges de données volumineux et l’absence de contrôle des erreurs peuvent annuler les gains obtenus. Une architecture efficace combine donc isolation du calcul, réutilisation des threads et mesure des performances.
Comprendre le fonctionnement des worker threads
Un worker thread est une instance JavaScript indépendante du thread principal. Il dispose de sa propre boucle d’événements, de sa mémoire et de son contexte d’exécution. Le programme principal communique avec lui grâce à des messages envoyés par les API postMessage() et on('message').
Un fichier minimal peut créer un worker à partir de lui-même :
// main.js
const { Worker } = require('node:worker_threads');
const worker = new Worker('./calcul.js', {
workerData: 40
});
worker.on('message', (resultat) => {
console.log('Résultat :', resultat);
});
worker.on('error', console.error);
worker.on('exit', (code) => {
if (code !== 0) console.error(`Arrêt inattendu : ${code}`);
});
Le fichier exécuté par le thread secondaire récupère les données initiales avec workerData :
// calcul.js
const { parentPort, workerData } = require('node:worker_threads');
let resultat = 1;
for (let i = 2; i <= workerData; i++) {
resultat *= i;
}
parentPort.postMessage(resultat);
Le code du worker ne bloque donc pas directement la boucle d’événements du processus principal. Cette séparation convient particulièrement aux fonctions synchrones et coûteuses en temps CPU. Elle ne remplace pas les API asynchrones pour les requêtes réseau ou les accès classiques aux fichiers.
Identifier les tâches qui gagnent à être parallélisées
Les worker threads sont pertinents lorsque le temps d’exécution dépend surtout du processeur. Le redimensionnement d’une grande image, le calcul de hachages, la génération de rapports, l’encodage vidéo, l’analyse de fichiers et certaines étapes de machine learning sont de bons candidats.
Une opération d’entrée-sortie lente ne devient pas plus rapide parce qu’elle est déplacée dans un worker. Dans ce cas, les API asynchrones de Node.js restent généralement préférables. Il faut aussi évaluer le coût de transfert des paramètres : envoyer plusieurs centaines de mégaoctets au worker peut consommer une part importante du bénéfice attendu.
Pour déterminer le bon découpage, il est utile de mesurer la durée du calcul, l’utilisation des cœurs, la latence observée par les requêtes et la consommation mémoire. Un benchmark réaliste doit comparer le traitement séquentiel, la création ponctuelle de workers et l’utilisation d’un pool. Les résultats changent selon la taille des données et le nombre de cœurs disponibles.
La parallélisation doit aussi respecter les limites de l’environnement de déploiement. Une application hébergée sur une plateforme cloud peut disposer de ressources CPU variables ; une comparaison des options, comme les solutions de déploiement cloud, aide à anticiper ces différences avant de dimensionner les workers.
Construire un pool de workers réutilisables
Créer un nouveau thread pour chaque tâche est simple, mais rarement optimal. Le démarrage d’un worker implique le chargement du runtime, l’initialisation du module et une consommation mémoire supplémentaire. Pour traiter de nombreuses tâches, un pool maintient un nombre limité de workers et leur attribue les jobs au fur et à mesure.
Le pool doit généralement définir une taille initiale liée au nombre de cœurs, avec une limite supérieure contrôlée. Une file d’attente reçoit les calculs en attente, tandis qu’un worker libre récupère le prochain travail. Cette organisation empêche une rafale de requêtes de lancer des dizaines de threads et de saturer la machine.
Chaque tâche devrait être associée à une promesse, à un identifiant et à un mécanisme de délai maximal. Le pool doit gérer les erreurs, les arrêts prématurés et les tâches qui dépassent leur budget de temps. Après plusieurs échecs, un worker peut être détruit puis remplacé afin d’éviter qu’un état corrompu ne persiste.
Cette logique gagne à être documentée et testée en équipe, avec une organisation inspirée des pratiques de la zone Agile : responsabilités explicites, critères de performance mesurables et validation progressive. L’objectif n’est pas de multiplier les abstractions, mais de rendre le comportement du système prévisible.
Transférer efficacement les données
Par défaut, Node.js copie les objets envoyés entre threads grâce à l’algorithme de clonage structuré. Cette approche prend en charge de nombreux types JavaScript, mais elle peut devenir coûteuse avec de grandes chaînes, des tableaux volumineux ou des objets profondément imbriqués.
Pour éviter une copie, il est possible de transférer la propriété d’un ArrayBuffer :
const buffer = new ArrayBuffer(1024 * 1024);
worker.postMessage({ buffer }, [buffer]);
Après le transfert, le buffer n’est plus utilisable par le thread qui l’a envoyé. Ce comportement doit être prévu dans le code, surtout lorsque plusieurs fonctions partagent la même référence. Les TypedArray et les buffers Node.js peuvent également être employés, à condition de vérifier précisément leur buffer sous-jacent.
SharedArrayBuffer permet à plusieurs threads d’accéder à une zone mémoire commune. Il réduit certains transferts, mais introduit des risques de concurrence. Les opérations coordonnées par Atomics sont nécessaires pour éviter les lectures incohérentes et les conditions de course. Cette technique convient aux scénarios exigeants, pas à une communication ordinaire entre quelques tâches.
Pour des messages simples, une structure compacte reste préférable. Il vaut mieux transmettre un identifiant de fichier, une plage d’octets ou des paramètres minimaux qu’un objet complet contenant des données qui existent déjà ailleurs. La réduction du volume échangé améliore souvent davantage les performances qu’une optimisation locale du calcul.
Sécuriser l’exécution et observer les performances
Un worker doit être traité comme une unité d’exécution indépendante. Les événements error et exit doivent être surveillés, et les promesses associées à chaque tâche doivent toujours être résolues ou rejetées. Sans cette discipline, une requête peut rester suspendue après un arrêt inattendu du thread.
Les journaux doivent distinguer le thread principal, le worker, l’identifiant de tâche et la durée du calcul. Des métriques telles que la longueur de la file, le nombre de workers actifs, la latence p95 et la consommation mémoire permettent de détecter la saturation. Les outils de profilage CPU de Node.js complètent ces mesures en révélant les fonctions réellement coûteuses.
Il faut aussi éviter de confondre parallélisme et multiplication aveugle des ressources. Un pool trop grand peut provoquer une compétition entre threads, augmenter les changements de contexte et réduire les performances globales. Une limite de concurrence, un système de retour arrière et une file d’attente bornée protègent le serveur lorsque la demande augmente.
Les applications d’intelligence artificielle illustrent bien cette nécessité. La génération de réponses, la préparation de données ou l’orchestration d’un chatbot peuvent combiner réseau, mémoire et calcul ; des ressources consacrées aux chatbots avec Bot Framework permettent de comparer les responsabilités avant de déplacer certaines étapes dans des workers Node.js. Le thread secondaire doit rester réservé aux opérations réellement bloquantes pour le processeur.
Adoptez une démarche progressive : commencez par mesurer le goulot d’étranglement, isolez une fonction pure, exécutez-la dans un worker, puis comparez les résultats avec une charge représentative. Ajoutez ensuite un pool, des limites et une instrumentation claire. Cette méthode permet d’exploiter le parallélisme de Node.js sans sacrifier la lisibilité ni la stabilité de l’application.