Wie Multi-Processing mir geholfen hat, meine JavaScript-Anwendung um das Vierfache zu beschleunigen

JavaScript wurde von Natur aus als Single-Threaded-Biest konzipiert. Doch in den wilden Gefilden des Computerwesens warten die als „Multiprocessing“ und „Multi-Core-Prozessoren“ bekannten Raubtiere darauf, gezähmt zu werden, um die Ausführung Ihres Codes auf beispiellose Geschwindigkeiten zu beschleunigen. 💪🚀

Ich habe es gewagt, in diesen Dschungel vorzudringen, meinen Code dem ultimativen Überlebenstest zu unterziehen und bin mit erstaunlichen Ergebnissen herausgekommen. 🏆 Jetzt sind Sie an der Reihe, mich auf dieser spannenden Suche zu begleiten. Wir werden tief in das Rätsel der Multiverarbeitung in Node.js eintauchen, bewaffnet mit fesselnden Codebeispielen und mit der Fackel 🔦 auf die spektakulären Ergebnisse meiner Experimente. 🍎🍏

Machen Sie sich bereit für dieses adrenalingeladene Abenteuer, in dem Sie die JavaScript- Leistung durch die Magie der Multiverarbeitung steigern! Schnallen Sie sich an und bereiten Sie sich darauf vor, uns in die faszinierende Welt des Codierens mit hoher Geschwindigkeit zu begeben.

Bevor wir uns zu sehr in die Tiefe wagen, statten wir uns mit einigen bewährten Werkzeugen aus. Wir werden einige Hilfsfunktionen erstellen, um die oft mühsame Rechenarbeit zu simulieren. Lassen Sie uns ein neues Artefakt erstellen, eine Datei mit dem Namen utils.js , und diese wesentlichen Beschwörungsformeln dort eintragen.

 // utils.js function generateRandomData(size) { const data = []; for (let i = 0; i < size; i++) { data.push(Math.random()); } return data; } function processData(data) { // performs some calculations on the array // to simulate high resource intensity let sum = 0; for (let num of data) { for (let j = 0; j < 1000000; j++) { sum += Math.sqrt(num); } } return sum; } module.exports = { generateRandomData, processData, };

Single-Threaded-Version

Die Ausführung in einem einzelnen Thread stellt einen fleißigen und zuverlässigen Ansatz zur Problemlösung dar. Die Single-Threaded-Version des Skripts kann visuell als solche beschrieben werden. Der Code der Single-Threaded-Version ist recht einfach. Wir erstellen Daten und versenden diese zur Verarbeitung.

 // sync.js const { generateRandomData, processData } = require("./utils"); const data = generateRandomData(30000); console.time("single-thread. Time:"); processData(data); console.timeEnd("single-thread. Time:");

Wir starten das Skript mit dem Befehl: node sync.js

Wir warten... und warten... und warten...

Und nach all dem Warten erhalten wir eine Nachricht mit der Angabe der Ausführungszeit des Skripts.

 single-thread. Time:: 25.888s

Dieser Ansatz ist in den meisten Fällen ausreichend. Aber es gibt einen Haken. Wer liebt bei klarem Verstand die Kunst des Wartens? Um diese quälende Verzögerung zu überwinden, sollten wir die volle Leistungsfähigkeit unserer Computer nutzen! Schließlich sind die meisten modernen Computer mit mehr als einem einzigen CPU-Kern ausgestattet!

Warum sollten wir diese zusätzlichen Kerne also ungenutzt lassen, wenn sie doch Zahlen verarbeiten und unsere Codeausführung beschleunigen könnten? Es ist an der Zeit, diese schlafenden Riesen zum Leuchten zu bringen und die pure Kraft des Multiprocessings freizuschalten! Lass uns eintauchen!

Mehrfach verarbeitete Version des Skripts

Durch den Multiprozess-Ansatz können wir mehrere Kerne unserer CPU nutzen und so die Leistung unseres Skripts um ein Vielfaches steigern. Der Prozess der Operation unseres mehrfach verarbeiteten Codes kann mit diesem Diagramm visualisiert werden.

Im Wesentlichen unterteilen wir einfach einen großen Datensatz in Segmente und weisen jedes Segment zur Verarbeitung einem separaten CPU-Kern zu.

Erstellen Sie eine Datei mit dem Titel multi-process.js und füllen Sie sie mit dem folgenden Inhalt.

 // multi-process.js const childProcess = require("child_process"); const utils = require("./utils"); const data = utils.generateRandomData(30000); const chunkSize = Math.ceil(data.length / 4); const chunks = []; for (let i = 0; i < 4; i++) { const start = i * chunkSize; const end = start + chunkSize; chunks.push(data.slice(start, end)); } console.time("multiProcessed"); const workers = []; let results = []; // result collection array for (let i = 0; i < chunks.length; i++) { const worker = childProcess.fork("./worker.js"); // pass its number and data to the workflow worker.send({ workerNumber: i, data: chunks[i] }); workers.push( new Promise((resolve, reject) => { worker.on("message", (result) => { results.push(result); // add the result to the result array resolve(); }); worker.on("error", reject); worker.on("exit", (code) => { if (code !== 0) { reject(new Error(`Worker stopped with exit code ${code}`)); } }); }) ); } Promise.all(workers) .then(() => { console.timeEnd("multiProcessed"); console.log("Processing results:", results); }) .catch((err) => console.error(err));

Dieser Code enthüllt die Orchestrierung eines einzelnen Worker-Prozesses in der Symphonie der mehrfach verarbeiteten Datenverarbeitung in Node.js.

Kurz gesagt, hier ist, was passiert:

• Der Worker erhält Daten und deren Nummer vom Hauptprozess über process.on('message') .

• Die Funktion processData führt Berechnungen für den Teil der Daten durch, der diesem Worker zugewiesen ist.

• Das Ergebnis wird über „process.send()“ an den Hauptprozess zurückgesendet.

• Der Worker wird mit Code 0 über process.exit() beendet.

  
  

Starten Sie das Skript mit dem Befehl: node multi-process.js

Halten Sie sich fest für den Turbo-Boost ...

Und wir kommen zu dem Schluss, dass der Code in 5 Sekunden funktioniert hat!

 Worker 0 started Worker 1 started Worker 2 started Worker 3 started ==================== Worker 1 finished ==================== Worker 2 finished ==================== Worker 3 finished ==================== Worker 0 finished multiProcessed: 5.266s Processing results: [ 4971422688.053512, 4989646323.157899, 4999088030.661542, 5008034869.924775 ]

Unser Skript hat viermal schneller gearbeitet! Ist das nicht großartig?

Die große Enthüllung: Testergebnisse

Voller Neugier ließ ich beide Skripte auf einem Computer laufen, der mit einem 4-Kern-Prozessor ausgestattet war, und wartete darauf, Zeuge der magischen Entfaltung zu werden:

• Der Solokünstler, unser Single-Threaded-Skript, verarbeitete die Daten sorgfältig in 25,8 Sekunden .

• Das leistungsstarke Team, unser Multithread-Skript, hat es in nur 5,2 Sekunden geschafft!

  
  

Erleben Sie die Leistungsfähigkeit von Multiprocessing – mehr als das Vierfache der Rechengeschwindigkeit!

Diese starken Kontraste verdeutlichen, wie Multiprocessing die Rechenleistung Ihrer Maschine drastisch steigern und die Ausführungszeit verkürzen kann.

Abschließende Gedanken

Unsere spannende Untersuchung zeichnet ein anschauliches Bild davon, wie Multiprocessing Rechenaufgaben in Node.js beschleunigen kann. Das Freigeben Ihres Codes auf jedem einzelnen Prozessorkern bietet einen spürbaren Leistungssprung, vergleichbar mit dem Wechsel vom Gehen zur Teleportation!

Es lohnt sich auf jeden Fall, diesen Pfeil in Ihren Codierungsköcher aufzunehmen und mit diesem Ansatz in Ihren Projekten zu experimentieren. Und mit dem Aufkommen von Worker Threads in Node.js ist die Implementierung von Multiprocessing ein Kinderspiel geworden.

Haben Sie beim Lesen einen Adrenalinstoß bekommen? Teilen Sie gerne Ihre eigenen Abenteuer mit Multiprocessing in Node.js in den Kommentaren unten! Lassen Sie uns weiterhin gemeinsam die Geheimnisse der Hochgeschwindigkeitscodierung lüften.