Eine kurze Analyse von Node.js mit worker_threads-Multithreads für die Parallelverarbeitung

Wie verwende ich Node.js für die Parallelverarbeitung? Der folgende Artikel stellt Ihnen vor, wie Sie Node Multithreading für die Parallelverarbeitung verwenden. Ich hoffe, er wird Ihnen hilfreich sein!

Viele Leute scheinen nicht zu verstehen, wie Single-Thread-NodeJS mit Multi-Thread-Backends konkurrieren kann.

Um herauszufinden, warum, müssen wir die wahre Bedeutung davon verstehen, dass Nodejs Single-Threaded sind.

JavaScript selbst wurde ursprünglich entwickelt, um einfache Dinge wie die Validierung von Formularen, das Erstellen von Antworten usw. zu tun. Erst 2009 ermöglichte Node.js-Erfinder Ryan Dahl das Schreiben von serverseitigem Code mit JavaScript.

Serverseitige Sprachen, die Multithreading unterstützen, verfügen über verschiedene Strukturen und Konstrukte zur Synchronisierung zwischen Threads und anderen Thread-orientierten Funktionen.

Die Unterstützung dieser Dinge bedeutet, dass JavaScript die gesamte Sprache ändern muss, was den Vorstellungen der Entwickler von JavaScript zuwiderläuft. Damit reines JavaScript Multithreading unterstützt, musste Dahl einen Workaround schaffen. Werfen wir einen Blick darauf!

---

Wie funktioniert Node.js?

Node.js verwendet zwei Arten von Threads: einen Hauptthread, der von einer Ereignisschleife verarbeitet wird, und mehrere sekundäre Threads in einem Pool von Arbeitsthreads. Der Mechanismus von

EreignisschleifeNode.js zur Verarbeitung nicht blockierender E/A-Vorgänge – obwohl JavaScript Single-Threaded ist – verlagert Vorgänge nach Möglichkeit auf den Systemkernel. Wenn eine JavaScript-Operation einen Thread blockiert, wird auch die Ereignisschleife blockiert.

Arbeitspool ist ein Ausführungsmodell, das separate Threads erzeugt und verarbeitet, dann Aufgaben synchron ausführt und die Ergebnisse an die Ereignisschleife zurückgibt. Die Ereignisschleife verwendet dann dieses Ergebnis, um den bereitgestellten Rückruf auszuführen.

Grundsätzlich wickelt der Worker-Pool asynchrone E/A-Vorgänge ab – hauptsächlich Interaktionen mit der Systemfestplatte und dem Netzwerk. Einige Module verwenden sofort einsatzbereite Worker-Pools, z. B. fs (I/O-lastig) oder crypto (CPU-lastig). Der Worker-Pool ist in libuv implementiert, was zu einer leichten, aber fast vernachlässigbaren Verzögerung führt, wenn Node Daten intern zwischen JavaScript und C++ übertragen muss.

Nachdem wir die Bedeutung von Ereignisschleife und Arbeitspool verstanden haben, schauen wir uns den folgenden Code an:

Im obigen Code müssen wir nicht synchron auf Ereignisse warten. Wir delegieren die Aufgabe, die Datei zu lesen, an den Worker-Pool und rufen die bereitgestellte Funktion mit dem Ergebnis auf. Da der Worker-Pool über einen eigenen Thread verfügt, kann die Ereignisschleife beim Lesen der Datei normal weiter ausgeführt werden.

---

Lassen Sie mich Ihnen vorstellen: worker_threads

Mit der Veröffentlichung von Node.js 10.5.0 erschienen worker_threads. Es unterstützt die Erstellung einfacher Multithread-Anwendungen in JavaScript.

worker_threads ist ein NodeJS-Modulpaket. Ein Thread-Worker ist ein Codestück (normalerweise aus einer Datei entnommen), das in einem separaten Thread generiert wird.

Es ist wichtig zu beachten, dass die Begriffe Thread-Worker, Worker und Thread oft synonym verwendet werden. Sie beziehen sich alle auf dasselbe.

Worker-Threads in Node.js sind nützlich für die Ausführung schwerer JavaScript-Aufgaben. Mit Hilfe von Threads können Worker JavaScript-Code problemlos parallel ausführen, was ihn schneller und effizienter macht. Wir können schwere Aufgaben erledigen, ohne den Hauptthread zu stören.

Worker-Threads wurden in älteren Versionen von Node.js nicht eingeführt. Aktualisieren Sie also zunächst Ihre Node.js, um loszulegen.

Erstellen Sie nun zwei Dateien, um Threads wie folgt zu implementieren:

Dateiname: worker.js

const { workerData, parentPort } = require('worker_threads');

console.log(`Write-up on how ${workerData} wants to chill with the big boys`);

parentPort.postMessage({ filename: workerData, status: 'Done' });

Dateiname: index.js

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

const runSerice = (workerData) => {
  return new Promise((resolve, reject) => {
    const worker = new Worker('./worker.js', { workerData });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0)
        reject(new Error(`Worker Thread stopped with exit code ${code}`));
    });
  });
};
const run = async () => {
  const result = await runSerice('Tunde Ednut');
  console.log(result);
};

run().catch((err) => console.error(err));

Ausgabe:

Mehr knotenbezogen Wissen, besuchen Sie bitte: nodejs Tutorial!

Das obige ist der detaillierte Inhalt vonEine kurze Analyse von Node.js mit worker_threads-Multithreads für die Parallelverarbeitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!