In einem früheren Artikel ?Node JS Internals“ haben wir die interne Architektur von Node JS besprochen und auch erl?utert, warum wir die Thread-Pool-Gr??e des Knotens erh?hen sollten, um mehrere Anfragen gleichzeitig zu verarbeiten. Ich habe Ihnen gesagt, dass Skalierbarkeit und Leistung nichts mit der Thread-Pool-Gr??e zu tun haben.

Für Skalierbarkeit und hohe Leistung k?nnen wir Clustering und Worker-Threads verwenden.

Clustering

Angenommen, Sie nehmen an einer gro?en Hochzeit teil und Tausende von G?sten nehmen an der Hochzeit teil. Es gibt eine Küche und ein Koch bereitet das Essen für alle diese G?ste zu. Klingt unvorhersehbar, oder? Sie nutzen nicht alle Ressourcen der Küche aus, wenn Sie nur einen Koch haben.

Genau das passiert in einer Node JS-Anwendung, die auf einer Multicore-CPU l?uft, wenn nur ein Kern für die Bearbeitung aller Anfragen verwendet wird. Obwohl unsere Maschine also über die Leistung von Multicores ohne Clustering verfügt, l?uft unsere Anwendung auf nur einem Core. Ein Kern ist für die Abwicklung der gesamten Arbeit verantwortlich.

Wenn in Ihrer Küche mehrere K?che arbeiten, kommt es zu einer Clusterbildung.

Clustering ist eine Technik, die es einer einzelnen Node-JS-Anwendung erm?glicht, mehrere CPU-Kerne effektiv zu nutzen.

Um Clustering zu implementieren, müssen Sie ein Cluster-Modul von Node JS verwenden.

const cluster = require('cluster');

Mithilfe dieses Clustermoduls k?nnen Sie mehrere Instanzen unserer Node JS-Anwendung erstellen. Diese Instanzen werden Worker genannt. Alle Mitarbeiter nutzen denselben Server-Port und bearbeiten eingehende Anfragen gleichzeitig.

Es gibt zwei Arten von Prozessen in der Clusterarchitektur.

1.Master-Prozess:

Der Master-Prozess ist wie der Hauptkoch in der Küche, der die Arbeiter verwaltet. Es initialisiert die Anwendung, richtet die Clustering-Umgebung ein und delegiert au?erdem Aufgaben an Arbeitsprozesse. Bewerbungsanfragen werden nicht direkt bearbeitet.

Was macht der Master-Prozess?

• Erstellt mehrere Arbeitsprozesse mithilfe der Methode ?cluster.fork()“. Au?erdem werden Worker neu gestartet, wenn sie abstürzen oder unerwartet beendet werden.

• Es stellt sicher, dass eingehende Anfragen auf alle Arbeitsprozesse verteilt werden. Unter Linux übernimmt dies ein Betriebssystem und unter Windows fungiert Node JS selbst als Load Balancer.

• Es erm?glicht die Kommunikation zwischen Arbeitern über IPC (Inter-Process Communication).

2.Arbeiterprozesse:

Worker-Prozesse sind die Instanz der Node JS-Anwendung, die vom Master-Prozess erstellt wurde. Jeder Prozess l?uft unabh?ngig auf einem separaten CPU-Kern und verarbeitet eingehende Anfragen.

Worker-Prozesse k?nnen nicht direkt miteinander kommunizieren, sie kommunizieren über den Master.

Der Arbeitsprozess verarbeitet die eingehende Anfrage und führt einige Aufgaben wie Datenbankabfragen, Berechnungen oder beliebige Anwendungslogik aus.

const cluster = require('cluster');

Hier überprüfen wir zun?chst, dass es sich um den Master-Prozess handelt. Wenn ja, werden Arbeitsprozesse erstellt.

In unserem Code erstelle ich einen Arbeitsprozess mit Cluster.fork().

Dies ist jedoch keine ideale M?glichkeit, einen Arbeitsprozess zu erstellen.

Angenommen, Sie erstellen 4 Arbeitsprozesse und Ihr System verfügt über zwei Kerne.

Um dieses Problem zu l?sen, anstatt hartcodierte Arbeitsprozesse zu erstellen, suchen Sie zun?chst die CPU-Kerne und berücksichtigen Sie dann, dass Daten Arbeitsprozesse erstellen.

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

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
    cluster.fork();
    cluster.fork();
    cluster.fork();
    cluster.fork();

} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

Ich verwende ein Dual-Core-System, daher sieht die Ausgabe so aus.

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

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
  const numCPUs = os.cpus().length;

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  console.log(`Worker ${process.pid} is running`);
  // Worker logic (e.g., server setup) goes here
}

Nun haben Sie eine Frage: Wenn Sie eine Dual-Core-CPU haben, warum werden dann 4 Arbeitsprozesse erstellt?

Das liegt daran, dass die Anzahl der logischen Kerne 4 betr?gt. Meine CPU unterstützt Hyperthreading oder Simultaneous Multi-Threading (SMT).

Arbeitsthreads

Im Restaurant nimmt der Kellner die Bestellung entgegen und gibt sie an ein Kochteam weiter, da das Kochen einige Zeit in Anspruch nimmt. Wenn Tischreinigung oder andere kellnerbezogene Arbeiten anfallen, übernimmt der Kellner diese. Wenn die Bestellung fertig ist, gibt der Koch dem Kellner das Essen zurück und der Kellner serviert es dem Kunden.

Dies ist das gleiche Szenario im Zusammenhang mit Arbeitsthreads. Wenn rechenintensive Aufgaben wie umfangreiche Datenverarbeitung, komplexe Berechnungen oder umfangreiche Algorithmen anfallen, delegiert der Hauptthread diese Aufgabe an den Arbeitsthread. Der Worker führt diese Aufgabe aus, nicht der Hauptthread.

*Warum ist das hilfreich? *

Wir wissen, dass die Node JS-Ereignisschleife Single-Threaded ist und wenn diese schwere Rechenarbeit vom Hauptthread erledigt wird, wird die Ereignisschleife blockiert. Wenn Sie diese Worker-Threads verwenden, werden diese schweren Aufgaben an Worker-Threads übergeben, und Worker-Threads führen diese Aufgaben aus, nicht der Haupt-Thread, sodass die Ereignisschleife nicht blockiert wird.

Worker-Threads k?nnen über ein Message-Passing-System mit dem Haupt-Thread kommunizieren und Daten k?nnen mithilfe von strukturiertem Klonen (Deep Copy) zwischen Threads gesendet werden.

Jetzt versuchen wir, die Funktionsweise der Arbeitsthreads nachzuahmen.

main.js (Hauptthread)

Master 12345 is running
Worker 12346 is running
Worker 12347 is running
Worker 12348 is running
Worker 12349 is running

worker.js (Worker-Thread)

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

function startWorker() {
  const worker = new Worker('./worker.js'); // Create a worker using worker.js

  // Listen for messages from the worker
  worker.on('message', (message) => {
    console.log('Message from worker:', message);
  });

  // Handle errors in the worker
  worker.on('error', (error) => {
    console.error('Worker error:', error);
  });

  // Handle worker exit
  worker.on('exit', (code) => {
    console.log(`Worker exited with code ${code}`);
  });

  // Send a message to the worker
  worker.postMessage({ num: 100 });
}

startWorker();

Wenn Daten gro?e Strukturen enthalten, werden sie tief geklont und übergangen, was zu einem gewissen Leistungsaufwand führen kann.

Funktionsweise des Codes

• Die Worker-Klasse wird verwendet, um neue Threads zu erzeugen.

• Sie k?nnen mit worker.postMessage Daten an den Arbeiter senden und mit worker.on('message', callback) auf Nachrichten warten.

• Im Worker-Thread ist parentPort die prim?re Schnittstelle für die Kommunikation mit dem Haupt-Thread.

• Sie k?nnen auf Nachrichten vom Hauptthread (parentPort.on('message')) warten und Nachrichten mit parentPort.postMessage zurücksenden.

Die Ausgabe wird sein:

const cluster = require('cluster');

Jetzt haben Sie auch eine Frage: Warum erstellen wir nicht Hunderte von Arbeitsthreads?

Der Grund dafür ist jedoch, dass, wenn Sie mehr Threads erstellen, als es Kerne gibt, die Threads um CPU-Zeit konkurrieren, was zu einem Kontextwechsel führt, der teuer ist und die Gesamtleistung verringert.

Wann sollten Sie Clustering, Worker-Threads oder beides in Node.js verwenden?

1. Wann werden Worker-Threads verwendet?

• CPU-gebundene Aufgaben:

Aufgaben beinhalten umfangreiche Berechnungen, wie z. B. Bild-/Videoverarbeitung, Datenkomprimierung oder -verschlüsselung, maschinelle Lerninferenz, wissenschaftliche Berechnungen

• Shared Memory ist erforderlich:

Sie müssen Daten effizient zwischen Threads teilen, ohne sie zu duplizieren.

• Single-Core-Nutzung:

Wenn Ihre Anwendung nur innerhalb eines einzelnen Prozesses skaliert werden muss, aber dennoch Parallelit?t für CPU-intensive Aufgaben ben?tigt.

2.Wann sollte Clustering verwendet werden?

• E/A-gebunden:

Zu den Aufgaben geh?rt die Bearbeitung einer gro?en Anzahl von Client-Anfragen, z. B. Web, Server, Chat-Anwendungen und APIs. Clustering hilft bei der horizontalen Skalierung, indem Anfragen auf alle CPU-Kerne verteilt werden.

• Isolierter Speicher:

Ihre Anwendung muss nicht viele Daten zwischen Prozessen teilen.

• Multi-Core-Nutzung:

Sie m?chten alle verfügbaren Kerne nutzen, indem Sie mehrere Node.js-Prozesse erzeugen.

3.Wann sollten sowohl Clustering als auch Worker-Threads verwendet werden?

• E/A-gebundene CPU-gebundene Aufgaben:

Die Anwendung verarbeitet HTTP-Anfragen, entlastet jedoch rechenintensive Aufgaben. Beispiel: Ein Webserver verarbeitet Datei-Uploads und führt eine Bildgr??en?nderung oder Videotranskodierung durch.

• Hohe Skalierbarkeit:

Für einen hohen Durchsatz ben?tigen Sie Parallelit?t sowohl auf Prozessebene als auch auf Thread-Ebene. Auf einer E-Commerce-Site stellt Clustering sicher, dass mehrere Prozesse eingehende Anfragen verarbeiten. Worker-Threads verarbeiten Hintergrundaufgaben wie das Generieren personalisierter Empfehlungen.

Vielen Dank.

Stellen Sie gerne Ihre Frage oder machen Sie Vorschl?ge.

Wenn Sie das informativ fanden, dann m?gen Sie es.

Das obige ist der detaillierte Inhalt vonClustering und Worker-Threads – Node JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!