Clustering und Worker-Threads – Node JS

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!