So verwenden Sie Multi-Core-CPU online in NodeJS

Mit der kontinuierlichen Aktualisierung der Computerhardwaretechnologie nimmt auch die Anzahl der Prozessorkerne allmählich zu. Viele Computer sind mittlerweile mit Multi-Core-CPUs ausgestattet, die es uns ermöglichen, Computerressourcen effizienter zu nutzen und die Anwendungsverarbeitung zu beschleunigen. Um jedoch die Vorteile von Multi-Core-CPUs voll ausnutzen zu können, müssen Anwendungen optimiert werden. In diesem Artikel wird erläutert, wie Sie die Vorteile von Multi-Core-CPUs in Node.js-Anwendungen optimal nutzen können.

Node.js ist eine serverseitige JavaScript-Sprache, die auf dem ereignisgesteuerten, nicht blockierenden I/O-Modell basiert. Sie ist bekannt für ihre effizienten I/O-Fähigkeiten, ihre geringe Belegung und ihre schnelle Entwicklungseffizienz. Sehr beliebt. Auf Multi-Core-CPUs kann die Leistung von Node.js-Anwendungen jedoch sehr gering werden, da Node.js standardmäßig nur einen einzelnen CPU-Kern verwenden kann. Wenn Sie die Vorteile von Multi-Core-CPUs voll ausnutzen möchten, müssen Sie das Cluster-Modul von Node.js verwenden.

Das Clustermodul ist ein Kernmodul von Node.js. Es kann Node.js-Anwendungen auf mehrere Unterprozesse verteilen und kann die Vorteile von Multi-Core-CPUs nutzen. Durch die Verwendung des Clustermoduls können Sie die Leistung Ihrer Node.js-Anwendung effektiv verbessern und sie gleichzeitig einfach und leicht erweiterbar halten.

Hier sind einige Möglichkeiten, das Cluster-Modul zu verwenden.

1. Erstellen Sie den Hauptprozess

Bevor Sie das Clustermodul verwenden, müssen Sie zunächst einen Hauptprozess erstellen. Der Hauptprozess ist ein Prozess, der keine eigentliche Geschäftslogik verarbeitet. Seine Hauptaufgabe besteht darin, untergeordnete Prozesse zu verwalten. Der Master-Prozess kann mithilfe des Master-Attributs des Cluster-Moduls erstellt werden:

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: 实际的业务逻辑处理
}

In diesem Beispielcode verwenden Sie das Cluster.isMaster-Attribut, um zu überprüfen, ob der aktuelle Prozess der Master-Prozess ist. Wenn es sich um den Hauptprozess handelt, startet er mehrere untergeordnete Prozesse und überwacht deren Exit-Ereignisse. Wenn es sich um einen Arbeitsprozess handelt, verarbeitet er die eigentliche Geschäftslogik.

2. Code Hot Reloading

Im eigentlichen Entwicklungsprozess kommt es häufig zu Codeänderungen. Um zu vermeiden, dass alle untergeordneten Prozesse neu gestartet werden, bietet das Clustermodul eine Hot-Reload-Methode zum Neustarten von Arbeitsprozessen. Sie können Cluster.on('SIGUSR2', ...) verwenden, um auf Signalereignisse zu warten. Wenn das Signal empfangen wird, starten Sie alle untergeordneten Prozesse neu:

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: 实际的业务逻辑处理
}

In diesem Beispielcode, wenn das Signal empfangen wird empfangen Wenn das SIGUSR2-Signal auftritt, wird ein SIGTERM-Signal an alle Arbeitsprozesse gesendet, um sie ordnungsgemäß herunterzufahren und dann neu zu starten.

3. Gemeinsamer Server-Port

In Node.js können mehrere Prozesse denselben Server-Port teilen. Dieser Ansatz verbessert die Anwendungsleistung, indem er es jedem Arbeitsprozess ermöglicht, eingehende Verbindungen zu verarbeiten. Wenn Sie das Cluster-Modul verwenden, können Sie Server-Ports mit dem folgenden Code freigeben:

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端口`);
  });
}

In diesem Beispielcode überwacht jeder Arbeitsprozess Port 3000. Wenn eine eingehende Verbindung eingeht, leitet der Server sie an verschiedene Arbeitsprozesse weiter und verbessert so die Leistung Ihrer Anwendung.

Zusammenfassung

Durch die Verwendung des Clustermoduls können Node.js-Anwendungen die Computerressourcen auf Multi-Core-CPUs problemlos vollständig nutzen. Bei der Verwendung des Clustermoduls müssen Sie die folgenden Punkte beachten:

• Der Hauptprozess ist nur für die Verwaltung untergeordneter Prozesse verantwortlich und kümmert sich nicht um die Geschäftslogik.
• Worker-Prozesse sollten unabhängig ablaufen und die eigentliche Geschäftslogik übernehmen.
• Sie können Code-Hot-Reloading verwenden, um einen Neustart aller Arbeitsprozesse zu vermeiden.
• Mehrere Prozesse können denselben Server-Port gemeinsam nutzen, um die Anwendungsleistung zu verbessern.

Um Multi-Core-CPUs effektiver nutzen zu können, sind weitere Optimierungen erforderlich, wie z. B. asynchrone I/O-Operationen, Speicherverwaltung und Codeoptimierung. Durch die Kombination verschiedener Technologien zur Optimierung Ihrer Anwendung können Sie eine bessere Leistung auf Multi-Core-CPUs erzielen und so den Benutzern ein besseres Erlebnis bieten.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Multi-Core-CPU online in NodeJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!