Comment utiliser un processeur multicœur en ligne dans nodejs

Avec la mise à jour continue de la technologie du matériel informatique, le nombre de cœurs de processeur augmente également progressivement. De nombreux ordinateurs sont désormais équipés de processeurs multicœurs, ce qui nous permet d'utiliser les ressources informatiques plus efficacement pour accélérer le traitement des applications. Cependant, pour tirer pleinement parti des processeurs multicœurs, les applications doivent être optimisées. Cet article explique comment tirer pleinement parti des processeurs multicœurs dans les applications Node.js.

Node.js est un langage JavaScript côté serveur basé sur un modèle d'E/S non bloquant basé sur des événements. Il est populaire pour ses capacités d'E/S efficaces, son encombrement léger et son efficacité de développement rapide. Cependant, sur les processeurs multicœurs, les performances des applications Node.js peuvent devenir très faibles car Node.js ne peut utiliser qu'un seul cœur de processeur par défaut. Si vous souhaitez profiter pleinement des processeurs multicœurs, vous devez utiliser le module cluster de Node.js.

Le module cluster est un module central de Node.js. Il peut distribuer des applications Node.js à plusieurs sous-processus. Chaque sous-processus s'exécute indépendamment et peut tirer parti des processeurs multicœurs. L'utilisation du module cluster peut améliorer efficacement les performances de votre application Node.js tout en la gardant simple et facilement extensible.

Voici quelques façons d'utiliser le module cluster.

1. Créer le processus principal

Avant d'utiliser le module cluster, vous devez d'abord créer un processus principal. Le processus principal est un processus qui ne gère aucune logique métier réelle. Sa tâche principale est de gérer les processus enfants. Le processus maître peut être créé à l'aide de l'attribut master du module cluster :

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已经退出`);
  });
} else {
  console.log(`工作进程 ${process.pid} 已经启动`);
  
  // TODO: 实际的业务逻辑处理
}

Dans cet exemple de code, l'attribut cluster.isMaster est utilisé pour vérifier si le processus actuel est le processus maître. S'il s'agit du processus principal, il démarrera plusieurs processus enfants et écoutera leurs événements de sortie. S'il s'agit d'un processus de travail, il gère la logique métier réelle.

2. Rechargement à chaud du code

Dans le processus de développement réel, des modifications de code se produisent souvent. Pour éviter de redémarrer tous les processus enfants, le module de cluster fournit une méthode de rechargement à chaud pour redémarrer les processus de travail. Vous pouvez utiliser cluster.on('SIGUSR2', ...) pour écouter les événements de signal Lorsque le signal est reçu, tous les processus enfants seront redémarrés :

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

function startWorker() {
  const worker = cluster.fork();
  console.log(`工作进程 ${worker.id} 已经启动`);
}

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    startWorker();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已经退出，重启中...`);
    startWorker();
  });
  
  cluster.on('SIGUSR2', () => {
    console.log('收到信号，重启所有工作进程...');
    const workers = Object.values(cluster.workers);
    
    const restartWorker = (workerIndex) => {
      const worker = workers[workerIndex];
      if (!worker) return;
      
      worker.on('exit', () => {
        if (!worker.exitedAfterDisconnect) return;
        console.log(`工作进程 ${worker.process.pid} 重新启动`);
        startWorker();
        restartWorker(workerIndex + 1);
      });
      
      worker.disconnect();
    }
    
    restartWorker(0);
  });
  
} else {
  console.log(`工作进程 ${process.pid} 已经启动`);
  
  // TODO: 实际的业务逻辑处理
}

Dans cet exemple de code, lorsque le signal SIGUSR2 est reçu, le Tous les processus de travail envoient un signal SIGTERM pour les arrêter correctement, puis les redémarrer.

3. Port de serveur partagé

Dans Node.js, plusieurs processus peuvent partager le même port de serveur. Cette approche améliore les performances des applications en permettant à chaque processus de travail de gérer les connexions entrantes. Lorsque vous utilisez le module cluster, vous pouvez partager les ports du serveur en utilisant le code suivant :

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已经退出`);
  });
} else {
  console.log(`工作进程 ${process.pid} 已经启动`);
  
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end('你好世界
');
  });
  
  server.listen(3000, (err) => {
    if (err) throw err;
    console.log(`工作进程 ${process.pid} 正在监听3000端口`);
  });
}

Dans cet exemple de code, chaque processus de travail écoutera sur le port 3000. Lorsqu'une connexion entrante arrive, le serveur l'achemine vers différents processus de travail, améliorant ainsi les performances de votre application.

Résumé

L'utilisation du module cluster peut facilement permettre aux applications Node.js d'utiliser pleinement les ressources informatiques sur les processeurs multicœurs. Lorsque vous utilisez le module cluster, vous devez faire attention aux points suivants :

• Le processus principal est uniquement responsable de la gestion des processus enfants et ne gère pas la logique métier.
• Les processus de travail doivent s'exécuter de manière indépendante et gérer la logique métier réelle.
• Le rechargement à chaud du code peut être utilisé pour éviter de redémarrer tous les processus de travail.
• Plusieurs processus peuvent partager le même port de serveur pour améliorer les performances des applications.

Pour utiliser plus efficacement les processeurs multicœurs, d'autres optimisations sont nécessaires, telles que les opérations d'E/S asynchrones, la gestion de la mémoire et l'optimisation du code. En combinant différentes technologies pour optimiser votre application, vous pouvez la rendre plus performante sur les processeurs multicœurs, offrant ainsi une meilleure expérience aux utilisateurs.

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!