Ich bin vor einiger Zeit über node.js gestolpert und mag es sehr. Aber bald stellte ich fest, dass es an der Fähigkeit mangelte, CPU-intensive Aufgaben auszuführen. Also fing ich an zu googeln und bekam diese Antworten, um das Problem zu lösen: Fasern, Webworker und Threads (Thread-a-Gogo). Welcher zu verwenden ist, ist eine Verwirrung und einer von ihnen muss definitiv verwendet werden - was ist der Zweck eines Servers, der nur gut in E / A ist und sonst nichts? Vorschläge benötigt!

AKTUALISIEREN:

Ich dachte an einen Weg zu spät; Ich brauche nur Vorschläge darüber. Nun, woran ich dachte, war Folgendes: Lassen Sie uns einige Threads haben (mit thread_a_gogo oder vielleicht Webworkern). Wenn wir jetzt mehr davon brauchen, können wir mehr schaffen. Der Erstellungsprozess ist jedoch begrenzt. (nicht vom System impliziert, aber wahrscheinlich wegen Overhead). Wenn wir das Limit überschreiten, können wir einen neuen Knoten teilen und Threads darüber erstellen. Auf diese Weise kann es weitergehen, bis wir eine Grenze erreichen (schließlich haben auch Prozesse einen großen Overhead). Wenn dieses Limit erreicht ist, beginnen wir, Aufgaben in die Warteschlange zu stellen. Immer wenn ein Thread frei wird, wird ihm eine neue Aufgabe zugewiesen. Auf diese Weise kann es reibungslos weitergehen.

Daran habe ich gedacht. Ist diese Idee gut? Ich bin ein bisschen neu in all diesen Prozessen und Threads, also habe ich kein Fachwissen darin. Bitte teilen Sie Ihre Meinungen.

Vielen Dank. :) :)

Node hat ein völlig anderes Paradigma und sobald es richtig erfasst ist, ist es einfacher, diese andere Art der Problemlösung zu erkennen. Sie benötigen niemals mehrere Threads in einer Knotenanwendung (1), da Sie auf unterschiedliche Weise dasselbe tun. Sie erstellen mehrere Prozesse. Es unterscheidet sich jedoch erheblich von der Prefork-PMM von Apache Web Server.

Nehmen wir zunächst an, wir haben nur einen CPU-Kern und entwickeln eine Anwendung (auf Node-Art), um einige Arbeiten auszuführen. Unsere Aufgabe ist es, eine große Datei zu verarbeiten, die byteweise über ihren Inhalt läuft. Der beste Weg für unsere Software besteht darin, die Arbeit am Anfang der Datei zu beginnen und sie Byte für Byte bis zum Ende zu verfolgen.

- Hey, Hasan, ich nehme an, du bist entweder ein Neuling oder eine sehr alte Schule aus der Zeit meines Großvaters !!! Warum erstellen Sie nicht einige Threads und machen es viel schneller?

- Oh, wir haben nur einen CPU-Kern.

-- Na und? Erstellen Sie einige Threads Mann, machen Sie es schneller!

- So funktioniert es nicht. Wenn ich Threads erstelle, werde ich es langsamer machen. Weil ich dem System viel Overhead für das Wechseln zwischen Threads hinzufügen werde, um ihnen eine angemessene Zeit zu geben und innerhalb meines Prozesses zu versuchen, zwischen diesen Threads zu kommunizieren. Zusätzlich zu all diesen Fakten muss ich mir auch überlegen, wie ich einen einzelnen Job in mehrere Teile aufteilen kann, die parallel ausgeführt werden können.

- Okay, okay, ich sehe, du bist arm. Verwenden wir meinen Computer, er hat 32 Kerne!

- Wow, du bist großartig, mein lieber Freund, vielen Dank. Ich schätze es!

Dann kehren wir zur Arbeit zurück. Jetzt haben wir dank unseres reichen Freundes 32 CPU-Kerne. Die Regeln, die wir einhalten müssen, haben sich gerade geändert. Jetzt wollen wir all diesen Reichtum nutzen, den wir bekommen.

Um mehrere Kerne zu verwenden, müssen wir einen Weg finden, unsere Arbeit in Teile zu unterteilen, die wir parallel verarbeiten können. Wenn es nicht Node wäre, würden wir dafür Threads verwenden. 32 Threads, einer für jeden CPU-Kern. Da wir jedoch einen Knoten haben, werden wir 32 Knotenprozesse erstellen.

Threads können eine gute Alternative zu Node-Prozessen sein, vielleicht sogar eine bessere. aber nur in einer bestimmten Art von Arbeit, in der die Arbeit bereits definiert ist und wir die vollständige Kontrolle darüber haben, wie wir damit umgehen sollen. Abgesehen davon ist Node's Weg für jede andere Art von Problem, bei dem der Job von außen auf eine Weise kommt, über die wir keine Kontrolle haben und die wir so schnell wie möglich beantworten möchten, unbestreitbar überlegen.

- Hey, Hasan, arbeitest du immer noch mit einem Thread? Was ist los mit dir, Mann? Ich habe dir gerade das zur Verfügung gestellt, was du wolltest. Du hast keine Ausreden mehr. Erstellen Sie Threads und beschleunigen Sie sie.

- Ich habe die Arbeit in Teile geteilt und jeder Prozess wird parallel an einem dieser Teile arbeiten.

- Warum erstellst du keine Threads?

- Entschuldigung, ich denke nicht, dass es brauchbar ist. Sie können Ihren Computer mitnehmen, wenn Sie möchten?

- Nein okay, ich bin cool, ich verstehe nur nicht, warum du keine Threads verwendest?

- Danke für den Computer. :) Ich habe die Arbeit bereits in Teile geteilt und Prozesse erstellt, um diese Teile parallel zu bearbeiten. Alle CPU-Kerne werden voll ausgelastet. Ich könnte dies mit Threads anstelle von Prozessen tun; Aber Node hat diesen Weg und mein Chef Parth Thakkar möchte, dass ich Node benutze.

- Okay, lassen Sie mich wissen, wenn Sie einen anderen Computer benötigen. : p

Wenn ich 33 statt 32 Prozesse erstelle, pausiert der Scheduler des Betriebssystems einen Thread, startet den anderen, pausiert ihn nach einigen Zyklen, startet den anderen erneut ... Dies ist unnötiger Overhead. Ich will es nicht. Auf einem System mit 32 Kernen würde ich nicht einmal genau 32 Prozesse erstellen wollen, 31 können schöner sein . Weil nicht nur meine Anwendung auf diesem System funktioniert. Ein wenig Platz für andere Dinge zu lassen, kann gut sein, besonders wenn wir 32 Zimmer haben.

Ich glaube, wir sind jetzt auf der gleichen Seite, wenn es darum geht, Prozessoren für CPU-intensive Aufgaben voll auszunutzen .

- Hmm, Hasan, es tut mir leid, dass ich dich ein wenig verspottet habe. Ich glaube, ich verstehe dich jetzt besser. Aber es gibt noch etwas, für das ich eine Erklärung brauche: Worum geht es bei der Ausführung von Hunderten von Threads? Ich habe überall gelesen, dass Threads viel schneller zu erstellen und dumm sind als Forking-Prozesse. Sie verzweigen Prozesse anstelle von Threads und denken, dass dies der höchste Wert ist, den Sie mit Node erzielen würden. Ist Node dann nicht für diese Art von Arbeit geeignet?

- Keine Sorge, ich bin auch cool. Jeder sagt diese Dinge, also denke ich, ich bin es gewohnt, sie zu hören.

-- So? Knoten ist nicht gut dafür?

- Node ist dafür perfekt geeignet, obwohl Threads auch gut sein können. Wie für den Aufwand für die Thread- / Prozesserstellung; Bei Dingen, die Sie häufig wiederholen, zählt jede Millisekunde. Ich erstelle jedoch nur 32 Prozesse und es wird eine winzige Zeit dauern. Es wird nur einmal passieren. Es wird keinen Unterschied machen.

- Wann möchte ich dann Tausende von Threads erstellen?

- Sie möchten niemals Tausende von Threads erstellen. Auf einem System, das Arbeiten von außen ausführt, z. B. einem Webserver, der HTTP-Anforderungen verarbeitet. Wenn Sie für jede Anforderung einen Thread verwenden, erstellen Sie viele Threads, viele davon.

- Knoten ist aber anders? Richtig?

-- Ja genau. Hier scheint Node wirklich. Wie ein Thread viel leichter als ein Prozess ist, ist ein Funktionsaufruf viel leichter als ein Thread. Der Knoten ruft Funktionen auf, anstatt Threads zu erstellen. Im Beispiel eines Webservers verursacht jede eingehende Anforderung einen Funktionsaufruf.

-- Hmm, interessant; Sie können jedoch nur eine Funktion gleichzeitig ausführen, wenn Sie nicht mehrere Threads verwenden. Wie kann dies funktionieren, wenn viele Anfragen gleichzeitig auf dem Webserver eingehen?

- Sie haben vollkommen Recht damit, wie Funktionen einzeln ausgeführt werden, niemals zwei parallel. Ich meine, in einem einzelnen Prozess wird jeweils nur ein Codebereich ausgeführt. Der OS Scheduler pausiert diese Funktion nicht und wechselt zu einer anderen, es sei denn, er pausiert den Prozess, um einem anderen Prozess Zeit zu geben, nicht einem anderen Thread in unserem Prozess. (2)

- Wie kann ein Prozess dann zwei Anfragen gleichzeitig bearbeiten?

- Ein Prozess kann Zehntausende von Anforderungen gleichzeitig verarbeiten, solange unser System über genügend Ressourcen (RAM, Netzwerk usw.) verfügt. Wie diese Funktionen ausgeführt werden, ist DER SCHLÜSSELUNTERSCHIED.

- Hmm, sollte ich jetzt aufgeregt sein?

- Vielleicht :) Node führt eine Schleife über eine Warteschlange. In dieser Warteschlange befinden sich unsere Jobs, dh die Anrufe, mit denen wir begonnen haben, eingehende Anforderungen zu verarbeiten. Der wichtigste Punkt hierbei ist die Art und Weise, wie wir unsere Funktionen für die Ausführung entwerfen. Anstatt eine Anfrage zu bearbeiten und den Anrufer warten zu lassen, bis wir den Job beendet haben, beenden wir unsere Funktion schnell, nachdem wir eine akzeptable Menge an Arbeit erledigt haben. Wenn wir an einem Punkt angelangt sind, an dem wir auf eine andere Komponente warten müssen, um etwas zu erledigen, und uns einen Wert zurückgeben müssen, anstatt darauf zu warten, beenden wir einfach unsere Funktion und fügen den Rest der Arbeit der Warteschlange hinzu.

- Es klingt zu komplex?

- Nein, nein, ich könnte komplex klingen. Aber das System selbst ist sehr einfach und macht durchaus Sinn.

Jetzt möchte ich aufhören, den Dialog zwischen diesen beiden Entwicklern zu zitieren, und meine Antwort nach einem letzten kurzen Beispiel für die Funktionsweise dieser Funktionen beenden.

Auf diese Weise machen wir das, was OS Scheduler normalerweise tun würde. Wir unterbrechen unsere Arbeit irgendwann und lassen andere Funktionsaufrufe (wie andere Threads in einer Umgebung mit mehreren Threads) laufen, bis wir wieder an der Reihe sind. Dies ist viel besser, als die Arbeit dem OS Scheduler zu überlassen, der versucht, jedem Thread auf dem System nur Zeit zu geben. Wir wissen, was wir viel besser machen als OS Scheduler, und es wird erwartet, dass wir aufhören, wenn wir aufhören sollten.

Im Folgenden finden Sie ein einfaches Beispiel, in dem wir eine Datei öffnen und lesen, um die Daten zu bearbeiten.

Synchroner Weg:

Open File
Repeat This:    
    Read Some
    Do the work

Asynchroner Weg:

Open File and Do this when it is ready: // Our function returns
    Repeat this:
        Read Some and when it is ready: // Returns again
            Do some work

Wie Sie sehen, fordert unsere Funktion das System auf, eine Datei zu öffnen, und wartet nicht darauf, dass sie geöffnet wird. Es beendet sich selbst, indem es die nächsten Schritte bereitstellt, nachdem die Datei fertig ist. Bei unserer Rückkehr führt Node andere Funktionsaufrufe in der Warteschlange aus. Nachdem alle Funktionen ausgeführt wurden, wechselt die Ereignisschleife zur nächsten Runde ...

Zusammenfassend hat Node ein völlig anderes Paradigma als die Multithread-Entwicklung. das heißt aber nicht, dass es an Dingen mangelt. Bei einem synchronen Job (bei dem wir die Reihenfolge und Art der Verarbeitung festlegen können) funktioniert dies ebenso wie die Multithread-Parallelität. Für einen Job, der wie Anfragen an einen Server von außen kommt, ist er einfach überlegen.

(1) Es sei denn, Sie erstellen Bibliotheken in anderen Sprachen wie C / C ++. In diesem Fall erstellen Sie immer noch keine Threads zum Teilen von Jobs. Für diese Art von Arbeit haben Sie zwei Threads, von denen einer die Kommunikation mit Node fortsetzt, während der andere die eigentliche Arbeit erledigt.

(2) Tatsächlich hat jeder Knotenprozess aus den gleichen Gründen, die ich in der ersten Fußnote erwähnt habe, mehrere Threads. Dies ist jedoch keineswegs so, als würden 1000 Threads ähnliche Arbeiten ausführen. Diese zusätzlichen Threads dienen dazu, E / A-Ereignisse zu akzeptieren und prozessübergreifende Nachrichten zu verarbeiten.

UPDATE (Als Antwort auf eine gute Frage in Kommentaren)

@ Mark, danke für die konstruktive Kritik. In Node's Paradigma sollten Sie niemals Funktionen haben, deren Verarbeitung zu lange dauert, es sei denn, alle anderen Aufrufe in der Warteschlange sind so konzipiert, dass sie nacheinander ausgeführt werden. Bei rechenintensiven Aufgaben stellen wir bei vollständiger Betrachtung des Bildes fest, dass es sich nicht um die Frage handelt, ob Threads oder Prozesse verwendet werden sollen. aber eine Frage von "Wie können wir diese Aufgaben in ausgewogener Weise in Unteraufgaben aufteilen, die wir parallel ausführen können, indem wir mehrere CPU-Kerne auf dem System verwenden?" Angenommen, wir verarbeiten 400 Videodateien auf einem System mit 8 Kernen. Wenn wir jeweils eine Datei verarbeiten möchten, benötigen wir ein System, das verschiedene Teile derselben Datei verarbeitet. In diesem Fall ist ein Multithread-Einzelprozesssystem möglicherweise einfacher zu erstellen und noch effizienter. Wir können Node weiterhin dafür verwenden, indem wir mehrere Prozesse ausführen und Nachrichten zwischen ihnen weitergeben, wenn eine gemeinsame Nutzung / Kommunikation des Status erforderlich ist. Wie ich bereits sagte, ist ein Multiprozess-Ansatz mit Nodesowie ein Multithread-Ansatz für diese Art von Aufgaben; aber nicht mehr als das. Wie ich bereits sagte, ist die Situation, in der Node glänzt, wenn diese Aufgaben als Eingabe aus mehreren Quellen in das System eingehen, da das gleichzeitige Aufrechterhalten vieler Verbindungen in Node im Vergleich zu einem Thread pro Verbindung oder einem Prozess pro Verbindung viel leichter ist System.

Wie für setTimeout(...,0)Anrufe; Manchmal kann es erforderlich sein, während einer zeitaufwändigen Aufgabe eine Pause einzulegen, damit Anrufe in der Warteschlange ihren Anteil an der Verarbeitung haben. Durch das Aufteilen von Aufgaben auf verschiedene Arten können Sie sich diese ersparen. Trotzdem ist dies kein wirklicher Hack, sondern nur die Art und Weise, wie Ereigniswarteschlangen funktionieren. Die Verwendung process.nextTickfür dieses Ziel ist auch viel besser, da bei der Verwendung setTimeoutBerechnungen und Überprüfungen der verstrichenen Zeit erforderlich sind, während dies process.nextTickeinfach das ist, was wir wirklich wollen: "Hey Aufgabe, gehen Sie zurück zum Ende der Warteschlange, Sie haben Ihren Anteil verwendet! ""

(Update 2016: Web-Mitarbeiter gehen in io.js - eine Node.js-Gabel Node.js v7 - siehe unten.)

(Update 2017: Web-Worker gehen nicht in Node.js v7 oder v8 - siehe unten.)

(Update 2018: Web - Arbeiter werden gehen in Node.js Knoten v10.5.0 - siehe weiter unten.)

Einige Klarstellungen

Nachdem ich die obigen Antworten gelesen habe, möchte ich darauf hinweisen, dass es in Web-Workern nichts gibt, was gegen die Philosophie von JavaScript im Allgemeinen und Node im Besonderen in Bezug auf Parallelität verstößt. (Wenn ja, würde es nicht einmal von der WHATWG diskutiert, geschweige denn in den Browsern implementiert).

Sie können sich einen Web-Worker als einen einfachen Microservice vorstellen, auf den asynchron zugegriffen wird. Es wird kein Status geteilt. Es bestehen keine Verriegelungsprobleme. Es gibt keine Blockierung. Es ist keine Synchronisation erforderlich. Genau wie bei der Verwendung eines RESTful-Dienstes aus Ihrem Node-Programm müssen Sie sich keine Sorgen machen, dass dieser jetzt "Multithread" ist, da sich der RESTful-Dienst nicht im selben Thread wie Ihre eigene Ereignisschleife befindet. Es ist nur ein separater Dienst, auf den Sie asynchron zugreifen, und darauf kommt es an.

Gleiches gilt für Web-Worker. Es ist nur eine API für die Kommunikation mit Code, der in einem völlig separaten Kontext ausgeführt wird. Ob es sich um einen anderen Thread, einen anderen Prozess, eine andere Gruppe, eine andere Zone, einen anderen Container oder einen anderen Computer handelt, ist aufgrund einer streng asynchronen, nicht blockierenden API völlig irrelevant. mit allen Daten als Wert übergeben.

Tatsächlich passen Web-Worker konzeptionell perfekt zu Node, das - wie viele Leute nicht wissen - im Übrigen ziemlich häufig Threads verwendet, und tatsächlich "läuft alles parallel außer Ihrem Code" - siehe:

• Verständnis der Ereignisschleife node.js von Mikito Takada
• Node.js von Felix Geisendörfer verstehen
• Grundlegendes zur Node.js-Ereignisschleife von Trevor Norris
• Node.js selbst blockiert, nur seine E / A werden von Jeremy Epstein nicht blockiert

Die Web-Worker müssen jedoch nicht einmal mithilfe von Threads implementiert werden. Sie können Prozesse, grüne Threads oder sogar RESTful-Services in der Cloud verwenden - solange die Web-Worker-API verwendet wird. Das Schöne an der Message-Passing-API mit Call-by-Value-Semantik ist, dass die zugrunde liegende Implementierung so gut wie irrelevant ist, da die Details des Parallelitätsmodells nicht offengelegt werden.

Eine Single-Threaded-Ereignisschleife ist perfekt für E / A-gebundene Operationen. Es funktioniert nicht so gut für CPU-gebundene Operationen, insbesondere für lange laufende. Dafür müssen wir mehr Prozesse erzeugen oder Threads verwenden. Das tragbare Verwalten untergeordneter Prozesse und der Kommunikation zwischen Prozessen kann sehr schwierig sein und wird häufig als Overkill für einfache Aufgaben angesehen. Die Verwendung von Threads bedeutet jedoch, dass Sperren und Synchronisierungsprobleme behoben werden müssen, die nur schwer richtig zu beheben sind.

Was oft empfohlen wird, ist, lang laufende CPU-gebundene Operationen in kleinere Aufgaben zu unterteilen (so etwas wie das Beispiel im Abschnitt "Ursprüngliche Antwort" meiner Antwort auf Speed ​​up setInterval ), aber es ist nicht immer praktisch und es werden nicht mehr verwendet als ein CPU-Kern.

Ich schreibe es, um die Kommentare zu verdeutlichen, die im Grunde besagten, dass Web-Worker für Browser und nicht für Server erstellt wurden (wobei vergessen wurde, dass über so ziemlich alles in JavaScript gesagt werden kann).

Knotenmodule

Es gibt nur wenige Module, die Web Worker zum Knoten hinzufügen sollen:

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

Ich habe keine davon verwendet, aber ich habe zwei kurze Beobachtungen, die relevant sein könnten: Ab März 2015 wurde Node-Webworker zuletzt vor 4 Jahren aktualisiert und Node-Webworker-Threads wurden zuletzt vor einem Monat aktualisiert. Außerdem sehe ich im Beispiel der Verwendung von Node-Webworker-Threads, dass Sie eine Funktion anstelle eines Dateinamens als Argument für den Worker-Konstruktor verwenden können, was subtile Probleme verursachen kann, wenn es mit Threads implementiert wird, die Speicher gemeinsam nutzen (es sei denn, die Funktionen werden nur für die .toString () -Methode verwendet und ansonsten in einer anderen Umgebung kompiliert. In diesem Fall kann es in Ordnung sein - ich muss mich eingehender damit befassen und nur meine Beobachtungen hier teilen.

Wenn es ein anderes relevantes Projekt gibt, das die Web-Worker-API in Node implementiert, hinterlassen Sie bitte einen Kommentar.

Update 1

Ich wusste es zum Zeitpunkt des Schreibens noch nicht, aber übrigens einen Tag bevor ich diese Antwort schrieb, wurden Web Worker zu io.js hinzugefügt .

( io.js ist eine Abzweigung von Node.js - siehe: Warum io.js beschlossen hat, Node.js , ein InfoWorld-Interview mit Mikeal Rogers, für weitere Informationen aufzuteilen.)

Dies beweist nicht nur, dass es in Web-Workern nichts gibt, was gegen die Philosophie von JavaScript im Allgemeinen und Node im Besonderen in Bezug auf Parallelität verstößt, sondern es kann auch dazu führen, dass Web-Worker ein erstklassiger Bürger in serverseitigem JavaScript wie io sind. js (und möglicherweise Node.js in der Zukunft) so wie es bereits in clientseitigem JavaScript in allen modernen Browsern vorhanden ist .

Update 2

In Update 1 und meinem Tweet bezog ich mich auf io.js Pull-Anfrage Nr. 1159, die jetzt zu Knoten PR Nr. 1159 umleitet, der am 8. Juli geschlossen und durch Knoten PR Nr. 2133 ersetzt wurde - der noch offen ist. Unter diesen Pull-Anfragen finden einige Diskussionen statt, die möglicherweise aktuellere Informationen zum Status von Web-Workern in io.js / Node.js enthalten.

Update 3

Neueste Informationen - danke an NiCk Newman für die Veröffentlichung in den Kommentaren: Da sind die Mitarbeiter: Erstes Implementierungs- Commit von Petka Antonov vom 6. September 2015, das in diesem Baum heruntergeladen und ausprobiert werden kann . Siehe Kommentare von NiCk Newman für Details.

Update 4

Ab Mai 2016 waren die letzten Kommentare zu den noch offenen PR # 2133 - Arbeitern: Die erste Implementierung war 3 Monate alt. Am 30. Mai bat mich Matheus Moreira, in den Kommentaren unten ein Update zu dieser Antwort zu veröffentlichen, und er fragte in den PR-Kommentaren nach dem aktuellen Status dieser Funktion .

Die ersten Antworten in der PR-Diskussion waren skeptisch, aber später schrieb Ben Noordhuis , dass "das Zusammenführen in der einen oder anderen Form auf meiner Aufgabenliste für Version 7 steht".

Alle anderen Kommentare schienen dem zuzustimmen, und ab Juli 2016 scheint es so sollten Web Worker in der nächsten Version von Node , Version 7.0, verfügbar sein, die voraussichtlich im Oktober 2016 veröffentlicht wird (nicht unbedingt in Form dieser genauen PR).

Vielen Dank an Matheus Moreira für den Hinweis in den Kommentaren und die Wiederbelebung der Diskussion auf GitHub.

Update 5

Ab Juli 2016 gab es nur wenige Module auf npm, die zuvor nicht verfügbar waren. Eine vollständige Liste der relevanten Module finden Sie unter npm nach Workern, Web-Workern usw. Wenn etwas Besonderes für Sie funktioniert oder nicht, senden Sie bitte eine Kommentar.

Update 6

Stand Januar 2017 es unwahrscheinlich, dass Web-Worker in Node.js zusammengeführt werden.

Die Pull-Anfrage # 2133 Arbeiter: Die erste Implementierung durch Petka Antonov vom 8. Juli 2015 wurde endgültig abgeschlossen am 11. Dezember 2016 von Ben Noordhuis Er kommentierte, dass "Multithreading-Unterstützung zu viele neue Fehlermodi für nicht genügend Nutzen hinzufügt" und "wir kann dies auch mit traditionelleren Mitteln wie Shared Memory und effizienterer Serialisierung erreichen. "

Weitere Informationen finden Sie in den Kommentaren zum PR 2133 auf GitHub.

Nochmals vielen Dank an Matheus Moreira für den Hinweis in den Kommentaren.

Update 6

Ich freue mich, Ihnen mitteilen zu können, dass vor einigen Tagen im Juni 2018 Web-Mitarbeiter in Node 10.5.0 als experimentelle Funktion mit der --experimental-workerFlagge aktiviert wurden .

Weitere Informationen finden Sie unter:

• Node v10.5.0 veröffentlicht Blogbeitrag
• Pull Request # 20876 - Worker: Erstimplementierung durch Anna Henningsen
• Mein ursprünglicher Tweet des Glücks, als ich erfuhr, dass dies in Version 10.5.0 enthalten ist:

🎉🎉🎉 Endlich! Ich kann das 7. Update meiner 3 Jahre alten Stack Overflow-Antwort vornehmen, in der ich argumentiere, dass das Threading von Web-Workern nicht gegen die Node-Philosophie verstößt, nur diesmal, dass wir es endlich verstanden haben! 😜👍

Ich komme aus der alten Denkschule, in der wir Multithreading verwendet haben, um Software schnell zu machen. Seit 3 ​​Jahren benutze ich Node.js und einen großen Unterstützer davon. Wie Hasanyasin ausführlich erklärt hat, wie der Knoten funktioniert und das Konzept der asynchronen Funktionalität. Aber lassen Sie mich hier einige Dinge hinzufügen.

Früher haben wir mit einzelnen Kernen und niedrigeren Taktraten verschiedene Möglichkeiten ausprobiert, um Software schnell und parallel arbeiten zu lassen. In DOS-Tagen führen wir jeweils ein Programm aus. Als in Windows haben wir begonnen, mehrere Anwendungen (Prozesse) zusammen auszuführen. Konzepte wie präventiv und nicht präventiv (oder kooperativ) wurden getestet. Wir wissen jetzt, dass Präventiv die Antwort für eine bessere Mehrfachverarbeitungsaufgabe auf Single-Core-Computern war. Es folgten die Konzepte von Prozessen / Aufgaben und Kontextwechsel. Als das Konzept des Threads, um die Belastung durch Prozesskontextwechsel weiter zu reduzieren. Der Faden wurde als leichte Alternative zum Laichen neuer Prozesse geprägt.

Ob es Ihnen gefällt oder nicht, Signal-Thread oder nicht Multi-Core oder Single-Core, Ihre Prozesse werden vom Betriebssystem vorab geprüft und zeitlich getrennt.

Nodejs ist ein einzelner Prozess und bietet einen asynchronen Mechanismus. Hier werden Jobs an ein unterliegendes Betriebssystem gesendet, um Aufgaben auszuführen, während wir in einer Ereignisschleife auf den Abschluss der Aufgabe warten. Sobald wir ein grünes Signal vom Betriebssystem erhalten, führen wir alles aus, was wir tun müssen. In gewisser Weise handelt es sich um kooperatives / nicht präemptives Multitasking. Daher sollten wir die Ereignisschleife niemals für einen sehr langen Zeitraum blockieren, da wir sonst unsere Anwendung sehr schnell beeinträchtigen.
Wenn es also jemals eine Aufgabe gibt, die in der Natur blockiert oder sehr zeitaufwändig ist, müssen wir sie in die präventive Welt von Betriebssystemen und Threads verzweigen. Es gibt gute Beispiele dafür in der libuv-Dokumentation . Wenn Sie die Dokumentation weiter lesen, werden Sie feststellen, dass FileI / O in Threads in node.js behandelt wird .

Also erstens geht es um das Design unserer Software. Zweitens findet immer eine Kontextumschaltung statt, egal was sie Ihnen sagen. Thread sind aus einem bestimmten Grund vorhanden und immer noch vorhanden. Der Grund dafür ist, dass sie schneller zwischen den Prozessen wechseln können.

Unter der Haube in node.js sind alle C ++ und Threads. Und Node bietet eine C ++ - Möglichkeit, seine Funktionalität zu erweitern und die Geschwindigkeit zu erhöhen, indem Threads dort verwendet werden, wo sie ein Muss sind, dh Aufgaben wie das Lesen von einer Quelle, die in eine Quelle schreibt, die Analyse großer Datenmengen usw. werden blockiert.

Ich weiß, dass die Antwort von hasanyasin die akzeptierte ist, aber für mich gibt es Threads, egal was Sie sagen oder wie Sie sie hinter Skripten verstecken. Zweitens teilt niemand die Dinge nur in Threads auf, nur um die Geschwindigkeit zu erhöhen, die hauptsächlich zum Blockieren von Aufgaben verwendet wird. Und Threads befinden sich im Backbone von Node.js, sodass Multithreading korrekt ist, bevor das Bashing vollständig ausgeführt wird. Außerdem unterscheiden sich Threads von Prozessen, und die Einschränkung, dass Knotenprozesse pro Kern vorhanden sind, gilt nicht genau für die Anzahl der Threads. Threads sind wie Unteraufgaben eines Prozesses. Tatsächlich werden Threads nicht in Ihrem Windows Task-Manager oder Linux-Top-Befehl angezeigt. wieder sind sie mehr wenig gewicht als prozesse

Ich bin nicht sicher, ob Webworker in diesem Fall relevant sind. Sie sind clientseitige Technologien (werden im Browser ausgeführt), während node.js auf dem Server ausgeführt wird. Soweit ich weiß, blockieren Fasern auch, dh sie sind freiwilliges Multitasking, sodass Sie sie verwenden können, aber Kontextwechsel selbst verwalten sollten yield. Threads könnten tatsächlich das sein, was Sie brauchen, aber ich weiß nicht, wie ausgereift sie in node.js sind.

worker_threadswurde implementiert und hinter einer Flagge in versendet [email protected]. Es ist noch eine erste Implementierung und es sind weitere Anstrengungen erforderlich, um sie in zukünftigen Versionen effizienter zu gestalten. Es lohnt sich, es spätestens einmal auszuprobieren node.

Nach Meinung vieler Node-Entwickler ist einer der besten Teile von Node seine Single-Thread-Natur. Threads bringen eine ganze Reihe von Schwierigkeiten mit gemeinsam genutzten Ressourcen mit sich, die Node vollständig vermeidet, indem er nur nicht blockierende E / A-Vorgänge ausführt.

Das heißt nicht, dass Node auf einen einzelnen Thread beschränkt ist. Es ist nur so, dass sich die Methode zum Abrufen der Thread-Parallelität von der gesuchten unterscheidet. Die Standardmethode für den Umgang mit Threads ist das Cluster- Modul, das standardmäßig mit Node selbst geliefert wird. Es ist ein einfacherer Ansatz für Threads, als sie manuell in Ihrem Code zu behandeln.

Für die asynchrone Programmierung in Ihrem Code (wie in Vermeidung verschachtelter Rückrufpyramiden) ist die Komponente [Future] in der Fibre- Bibliothek eine gute Wahl. Ich würde auch vorschlagen, dass Sie sich Asyncblock ansehen, das auf Fasern basiert. Fasern sind nett, weil sie es Ihnen ermöglichen, Rückrufe zu verbergen, indem Sie den Stapel duplizieren und dann bei Bedarf zwischen Stapeln auf einem einzelnen Thread wechseln. Spart Ihnen den Ärger mit echten Fäden und bietet Ihnen gleichzeitig die Vorteile. Der Nachteil ist, dass Stapelspuren bei der Verwendung von Fasern etwas seltsam werden können, aber sie sind nicht schlecht.

Wenn Sie sich nicht um asynchrone Dinge kümmern müssen und mehr daran interessiert sind, viel zu verarbeiten, ohne zu blockieren, ist ein einfacher Aufruf von process.nextTick (Rückruf) von Zeit zu Zeit alles, was Sie brauchen.

Vielleicht helfen weitere Informationen darüber, welche Aufgaben Sie ausführen. Warum sollten Sie (wie Sie in Ihrem Kommentar zur Antwort von genericdave erwähnt haben) viele tausend davon erstellen müssen? Die übliche Vorgehensweise in Node besteht darin, einen Arbeitsprozess (mit Fork oder einer anderen Methode) zu starten, der immer ausgeführt wird und über Nachrichten kommuniziert werden kann. Mit anderen Worten, starten Sie nicht jedes Mal einen neuen Mitarbeiter, wenn Sie die von Ihnen ausgeführte Aufgabe ausführen müssen, sondern senden Sie einfach eine Nachricht an den bereits ausgeführten Mitarbeiter und erhalten Sie eine Antwort, wenn diese erledigt ist. Ehrlich gesagt kann ich nicht sehen, dass das Starten von vielen tausend tatsächlichen Threads auch sehr effizient wäre. Sie sind immer noch durch Ihre CPUs eingeschränkt.

Nachdem ich das alles gesagt habe, habe ich in letzter Zeit viel mit Hook.io gearbeitet, was für diese Art des Abladens von Aufgaben in andere Prozesse sehr gut zu funktionieren scheint. Vielleicht kann es das erreichen, was Sie brauchen.