So erstellen Sie Threads in nodejs

Gibt es eine Möglichkeit, Threads zum gleichzeitigen Ausführen mehrerer Methoden zu erstellen?

Auf diese Weise sollten alle anderen Threads beendet werden, wenn eine Methode zwischen allen anderen Threads fehlschlägt.

Jeder node.js-Prozess ist vom Design her ein einzelner Thread. Um mehrere Threads zu erhalten, müssen Sie mehrere Prozesse haben (Wie einige andere Poster bereits erwähnt haben, gibt es auch Bibliotheken, auf die Sie verlinken können, damit Sie mit Threads in Node arbeiten können. Ohne diese Bibliotheken gibt es jedoch keine solche Funktion Siehe Antwort von Shawn Vincent unter Bezugnahme auf https://github.com/audreyt/node-webworker-threads )

Sie können untergeordnete Prozesse von Ihrem Hauptprozess aus starten, wie hier in der Dokumentation zu node.js gezeigt: http://nodejs.org/api/child_process.html . Die Beispiele auf dieser Seite sind ziemlich gut und ziemlich einfach.

Ihr übergeordneter Prozess kann dann bei jedem gestarteten Prozess auf das Abschlussereignis achten und dann das Schließen der anderen Prozesse erzwingen, die Sie gestartet haben, um den Typ einer Fail-All-Stop-Strategie zu erreichen, über die Sie sprechen.

Siehe auch: Node.js auf Mehrkernmaschinen

Es gibt auch mindestens eine Bibliothek für das native Threading in Node.js: Node-Webworker-Threads

https://github.com/audreyt/node-webworker-threads

Dies implementiert im Wesentlichen die Web Worker-Browser-API für node.js.

Ab Knoten 10.5 gibt es jetzt Unterstützung für Multithreading , dies ist jedoch experimentell . Hoffe das wird bald stabil.

Kasse folgende Ressourcen:

• PR-Thread .
• Offizielle Dokumentation
• Blog-Artikel: Threads in Node 10.5.0: ein praktisches Intro

Update :

Ab Knoten v11.7.0 müssen Sie kein --experimental-workerFlag mehr verwenden.

Versionshinweis: https://nodejs.org/en/blog/release/v11.7.0/

Sie können Multithreading mit Napa.js erhalten.

https://github.com/Microsoft/napajs

"Napa.js ist eine auf V8 basierende JavaScript-Laufzeit mit mehreren Threads, die ursprünglich für die Entwicklung hoch iterativer Dienste mit kompromissloser Leistung in Bing entwickelt wurde. Im Laufe der Entwicklung finden wir es nützlich, Node.js in CPU-gebundenen Aufgaben zu ergänzen Napa.js wird als Node.js-Modul verfügbar gemacht und kann auch ohne Node.js-Abhängigkeit in einen Host-Prozess eingebettet werden. "

Wenn Sie Rx verwenden, ist es ziemlich einfach, rxjs-cluster anzuschließen, um die Arbeit in parallele Ausführung aufzuteilen. (Haftungsausschluss: Ich bin der Autor)

https://www.npmjs.com/package/rxjs-cluster

Ich brauchte echtes Multithreading in Node.js und was für mich funktionierte, war das Thread- Paket. Es wird ein anderer Prozess mit einer eigenen Node.js-Nachrichtenschleife erzeugt, sodass sie sich nicht gegenseitig blockieren. Das Setup ist einfach und die Dokumentation bringt Sie schnell zum Laufen. Ihr Hauptprogramm und die Mitarbeiter können auf beide Arten kommunizieren, und die "Threads" der Mitarbeiter können bei Bedarf beendet werden.

Da Multithreading und Node.js ein kompliziertes und viel diskutiertes Thema sind, war es ziemlich schwierig, ein Paket zu finden, das für meine spezifischen Anforderungen geeignet ist. Für die Aufzeichnung funktionierten diese für mich nicht :

• winziger Arbeiter erlaubte das Laichen von Arbeitern, aber sie schienen dieselbe Nachrichtenschleife zu teilen (aber es könnte sein, dass ich etwas falsch gemacht habe - Threads hatten mehr Dokumentation, was mir das Vertrauen gab, dass es wirklich mehrere Prozesse verwendete, also ging ich weiter, bis es funktionierte).
• Webworker-Threads erlaubten keine requireModule in Workern , die ich brauchte

Und für diejenigen, die fragen, warum ich echtes Multithreading benötige : Für eine Anwendung mit Raspberry Pi und Interrupts. Ein Thread behandelt diese Interrupts und ein anderer kümmert sich um das Speichern der Daten (und mehr).

Die Version 10.5.0 von nodejs hat Multithreading in Node.js angekündigt . Die Funktion ist noch experimentell. Es ist jetzt ein neues Worker_Threads- Modul verfügbar.

Sie können Worker-Threads verwenden, wenn Sie Node.js 10.5.0 oder höher ausführen. Dies ist jedoch eine experimentelle API . Es ist standardmäßig nicht verfügbar: Sie müssen es mit  --experimental-worker aktivieren, wenn Sie Node.js aufrufen.

Hier ist ein Beispiel mit aktiviertem ES6 und worker_threads , das in Version 12.3.1 getestet wurde

//package.json

  "scripts": {
  "start": "node  --experimental-modules --experimental- worker index.mjs"
  },

Jetzt müssen Sie Worker aus worker_threads importieren . Hinweis: Sie müssen Ihre js- Dateien mit der Erweiterung '.mjs' für die ES6-Unterstützung deklarieren .

//index.mjs
import { Worker } from 'worker_threads';

const spawnWorker = workerData => {
    return new Promise((resolve, reject) => {
        const worker = new Worker('./workerService.mjs', { workerData });
        worker.on('message', resolve);
        worker.on('error', reject);
        worker.on('exit', code => code !== 0 && reject(new Error(`Worker stopped with 
        exit code ${code}`)));
    })
}

const spawnWorkers = () => {
    for (let t = 1; t <= 5; t++)
        spawnWorker('Hello').then(data => console.log(data));
}

spawnWorkers();

Schließlich erstellen wir eine workerService.mjs

//workerService.mjs
import { workerData, parentPort, threadId } from 'worker_threads';

// You can do any cpu intensive tasks here, in a synchronous way
// without blocking the "main thread"
parentPort.postMessage(`${workerData} from worker ${threadId}`);

Ausgabe:

npm run start

Hello from worker 4
Hello from worker 3
Hello from worker 1
Hello from worker 2
Hello from worker 5

Es gibt jetzt auch https://github.com/xk/node-threads-a-gogo , obwohl ich mir über den Projektstatus nicht sicher bin.

NodeJS enthält jetzt Threads (als experimentelle Funktion zum Zeitpunkt der Beantwortung).

Möglicherweise suchen Sie nach Promise.race(nativer E / A-Rennlösung, keine Threads)

Angenommen, Sie (oder andere, die diese Frage suchen) möchten Threads ausführen, um Fehler zu vermeiden und die Kosten für E / A-Vorgänge zu vermeiden. Dies ist eine einfache und native Methode, um dies zu erreichen (ohne Threads). Der Knoten ist für Single-Threads ausgelegt (siehe Ereignisschleife). Vermeiden Sie daher nach Möglichkeit die Verwendung von Threads. Wenn meine Annahme richtig ist, empfehle ich die Verwendung Promise.racemit setTimeout(Beispiel im Link). Mit dieser Strategie würden Sie eine Liste von Versprechungen erstellen, die jeweils eine E / A-Operation versuchen, und das Versprechen ablehnen, wenn ein Fehler auftritt (andernfalls Zeitüberschreitung). Die Promise.raceAussage wird nach der ersten Auflösung / Ablehnung fortgesetzt, was genau das zu sein scheint, was Sie wollen. Hoffe das hilft jemandem!

Node.js verwendet kein Threading. Laut seinem Erfinder ist das ein Schlüsselmerkmal. Zum Zeitpunkt der Erfindung waren die Fäden langsam, problematisch und schwierig. Node.js wurde als Ergebnis einer Untersuchung einer effizienten Single-Core-Alternative erstellt. Die meisten Node.js-Enthusiasten zitieren immer noch das alte Argument, als ob die Threads in den letzten 50 Jahren nicht verbessert worden wären.

Wie Sie wissen, wird Node.js zum Ausführen von JavaScript verwendet. Die JavaScript-Sprache hat sich im Laufe der Jahre ebenfalls entwickelt. Es gibt jetzt Möglichkeiten, mehrere Kerne zu verwenden - dh was Threads tun. Durch die Weiterentwicklung von JavaScript können Sie in Ihren Anwendungen Multi-Core-Multitasking durchführen. user158 weist darauf hin, dass Node.js ein bisschen damit spielt. Ich weiß nichts darüber. Aber warum warten Sie, bis Node.js das Angebot von JavaScript genehmigt hat?

Google für JavaScript-Multithreading anstelle von Node.js Multithreading. Sie erfahren mehr über Web Worker, Versprechen und andere Dinge.