Ereignisschleife im Knoten js

Obwohl Javascript eine Single-Threaded-Sprache ist, kann Node.js dem Betriebssystem Aufgaben zuweisen, sodass es mehrere Aufgaben gleichzeitig verarbeiten kann. Da die Abläufe im Betriebssystem multi-threaded sind, müssen mehrere Aufgaben gleichzeitig erledigt werden. Der mit jedem Vorgang verbundene Rückruf wird der Ereigniswarteschlange hinzugefügt und von Node.js so geplant, dass er ausgeführt wird, wenn die angegebene Aufgabe abgeschlossen ist.

Um effizienten und zuverlässigen Node.js-Code schreiben zu können, muss der Benutzer über ein solides Verständnis von Ereignisschleifen verfügen. Es kann auch bei der effektiven Behebung von Leistungsproblemen hilfreich sein. Die Ereignisschleife in Node.js spart Speicher und ermöglicht es Ihnen, mehrere Dinge gleichzeitig zu erledigen, ohne darauf warten zu müssen, dass jede einzelne Aufgabe abgeschlossen ist. Der Begriff „asynchron“ bezieht sich auf jede Javascript-Funktion, die im Hintergrund läuft, ohne eingehende Anfragen zu blockieren.

Bevor wir direkt zu Ereignisschleifen übergehen, werfen wir einen Blick auf verschiedene Aspekte der Programmiersprache Javascript.

Javascript als asynchrone Programmiersprache

Werfen wir einen Blick auf die Konzepte der asynchronen Programmierung. Javascript wird in Web-, Mobil- und Desktop-Anwendungen verwendet. Es ist jedoch zu beachten, dass Javascript eine synchrone Computerprogrammiersprache mit einem Thread ist.

Zum Verständnis des Konzepts wird ein einfaches Codebeispiel gegeben.

In diesem Code werden zwei einfache Funktionen erstellt und Methode1 wird zuerst aufgerufen, sodass zuerst Methode1 protokolliert wird und dann mit der nächsten fortgefahren wird.

Ausgabe

Javascript als synchrone Programmiersprache

Javascript ist eine synchrone Programmiersprache und führt jede Zeile Schritt für Schritt von oben nach unten aus, wobei jeweils nur eine Zeile ausgeführt wird. Im oben angegebenen Beispielcode wird zuerst Methode1 im Terminal protokolliert und dann Methode2.

Javascript als Blockierungssprache

Da Javascript eine synchrone Sprache ist, verfügt es über eine Blockierungsfunktion. Es spielt keine Rolle, wie lange es dauert, einen laufenden Prozess abzuschließen, aber ein neuer Prozess wird erst gestartet, wenn der vorherige abgeschlossen ist. Nehmen wir im obigen Codebeispiel an, dass sich in Methode 1 eine Menge Codeskript befindet, egal wie lange es dauert, entweder 10 Sekunden oder eine Minute, Methode 2 wird erst dann ausgeführt, wenn der gesamte Code in Methode 1 ausgeführt wurde.

Benutzer haben dies möglicherweise beim Surfen festgestellt. Wenn eine Webanwendung in einem Browser im Back-End ausgeführt wird, wird ein riesiger Codeblock ausgeführt, sodass der Browser für einige Zeit eingefroren zu sein scheint, bevor er den Kontrollzugriff an den Benutzer zurückgibt. Dieses Verhalten wird als Blockierung bezeichnet. Der Browser kann keine weiteren eingehenden Anfragen entgegennehmen, bis die aktuelle Anfrage verarbeitet wurde.

Javascript ist eine Single-Threaded-Sprache

Um ein Programm in Javascript auszuführen, wird die Thread-Funktionalität verwendet. Threads können jeweils nur eine Aufgabe ausführen. Andere Programmiersprachen unterstützen Multithreading und können mehrere Aufgaben parallel ausführen. Javascript enthält nur einen Thread zum Ausführen eines beliebigen Codeskripts.

Warten in Javascript

Wie aus dem Namen in diesem Abschnitt hervorgeht, müssen wir auf die Bearbeitung unserer Anfrage warten, um fortzufahren. Das Warten kann mehrere Minuten dauern, in denen keine weiteren Anfragen berücksichtigt werden. Wenn das Codeskript ohne Wartezeit fortgesetzt wird, tritt im Code ein Fehler auf. Einige Funktionen müssen in Javascript oder genauer gesagt Node.js implementiert werden, um den Code asynchron zu machen.

Nachdem wir nun die verschiedenen Aspekte von Javascript verstanden haben, wollen wir anhand einiger einfacher Beispiele synchron und asynchron verstehen.

Synchrone Ausführung von Code in Javascript

Synchron bedeutet, dass der Code sequentiell oder einfacher Schritt für Schritt ausgeführt wird, beginnend von oben und dann Zeile für Zeile nach unten.

Nachfolgend finden Sie ein Beispiel, das zum Verständnis beitragen kann:

In diesem Code gibt es drei console.log-Anweisungen, von denen jede etwas ausgibt. Zuerst wird die erste Anweisung, die in der Konsole „Eins“ ausgeben soll, für 1 ms (geschätzt) an den Aufrufstapel gesendet und dann im Terminal protokolliert. Danach wird die zweite Anweisung in den Aufrufstapel verschoben und die Zeit beträgt nun 2 ms, wobei eine aus der vorherigen hinzugefügt wird und dann „Zwei“ in der Konsole protokolliert wird. Schließlich wird die letzte Anweisung in den Aufrufstapel verschoben. Die Zeit beträgt derzeit 3 ​​ms und es wird „Drei“ in der Konsole protokolliert.

Der obige Code kann durch Aufrufen des folgenden Befehls ausgeführt werden:

Ausgabe

Die Funktionsweise ist oben ausführlich erklärt und wenn man sie beachtet, wird die Ausgabe im Handumdrehen in die Konsole eingeloggt:

Asynchrone Ausführung von Code in Javascript

Lassen Sie uns nun denselben Code umgestalten, indem wir Rückrufe einführen und den Code asynchron machen. Der obige Code kann wie folgt umgestaltet werden:

In diesem Code oben:

• Drei Funktionen werden zum Drucken von „Eins“, „Zwei“ und „Drei“ deklariert. Jede Funktion verfügt über einen Rückrufparameter, der die sequentielle Ausführung von Code ermöglicht.
• Mit der Funktion setTimeout wird ein Timeout festgelegt und es gibt eine console.log-Anweisung zum Drucken nach einer bestimmten Verzögerung.
• Es werden zwei Meldungen gedruckt: „Start des Programms“ und „Ende des Programms“, die den Beginn und das Ende des Programms anzeigen.
• Das Programm beginnt mit der Ausgabe von „Start des Programms“, woraufhin die Funktion „printOne“ mit einer Verzögerung von 1 Sekunde ausgeführt wird, dann die Funktion „printTwo“ mit einer Verzögerung von 2 Sekunden und schließlich die Funktion „printThree“ mit einer Verzögerung von 3 Sekunden Verzögerung.
• Das Programm wartet nicht auf die asynchronen Codeausführungen innerhalb der setTimeouts-Funktionen, die die Anweisung „Ende des Programms“ protokollieren, bevor es Eins, Zwei und Drei druckt.

Ausgabe

Führen Sie den obigen Code aus, indem Sie diesen Befehl im Terminal ausführen:

Jetzt würde die Ausgabe im Terminal asynchron wie folgt angezeigt werden:

Nachdem wir nun ein umfassendes Verständnis der synchronen und asynchronen Ausführung haben, wollen wir unser Konzept der Ereignisschleife in Node.js festigen.

Node.js: Ereignisschleifenmechanismus

Die Ausführung sowohl synchroner als auch asynchroner Aufgaben wird durch die Ereignisschleife in Node.js verwaltet. Die Ausführung wird aufgerufen, sobald das Node.js-Projekt gestartet wird, und überträgt die komplexen Aufgaben reibungslos an das System. Dadurch wird sichergestellt, dass andere Aufgaben reibungslos im Hauptthread ausgeführt werden können.

Visuelle Erklärung der Ereignisschleife in Node.js

Die Ereignisschleife ist in Node.js kontinuierlich und halbunendlich. Die Ereignisschleife wird durch den Start des Node.js-Codeskripts aufgerufen und ist für die Durchführung asynchroner API-Aufrufe und den Aufruf von Prozessen verantwortlich.Tick() und die Planung von Timern setzen dann die Ausführung der Ereignisschleife fort.

In Node.js verarbeiten fünf Haupttypen von Warteschlangen Rückrufe:

• Die „Timer-Warteschlange“, allgemein als Min-Heap bekannt, ist für die Verarbeitung von Rückrufen verantwortlich, die mit „setTimeout“ und „setInterval“ verbunden sind.
• Die Rückrufe für asynchrone Operationen wie in „fs“- und „http“-Modulen werden von „I/O Queue“ verarbeitet.
• Die „Check Queue“ enthält Rückrufe für die „setImmediate“-Funktion, die nur für Node gilt.
• Die „Close Queue“ verwaltet Rückrufe, die mit dem Abschlussereignis einer asynchronen Aufgabe verbunden sind.
• Schließlich gibt es in der „Micro Task“-Warteschlange zwei verschiedene Warteschlangen:
  • Die „nextTick“-Warteschlange enthält Rückrufe, die mit der Funktion „process.nextTick“ verknüpft sind.
  • Die „Promise“-Warteschlange steuert Rückrufe im Zusammenhang mit nativem Promise.

Event-Loop-Funktionalität in Node.js

Die Ereignisschleife funktioniert unter bestimmten Anforderungen, die die Reihenfolge der Rückrufausführung steuern. Dem synchronen Javascript-Code des Benutzers wird zu Beginn des Prozesses Priorität eingeräumt, sodass die Ereignisschleife erst beginnt, wenn der Aufrufstapel geleert wird. Die folgende Ausführungssequenz folgt einem strukturierten Muster:

Den Rückrufen in der Mikrotask-Warteschlange wird die höchste Priorität eingeräumt, dann werden die Aufgaben in der nextTick-Warteschlange ausgeführt, gefolgt von den Aufgaben in der Promise-Warteschlange. Die Prozesse in den Warteschlangenrückrufen des Timers werden dann verarbeitet, woraufhin die Mikrotask-Warteschlange nach jedem Timer-Callback erneut besucht wird. Die Rückrufe in den E/A-, Prüf- und Schließwarteschlangen werden dann in einem ähnlichen Muster wie die Mikrotask-Warteschlange ausgeführt, die nach jeder Phase besucht wird.

Die Schleife wird weiterhin ausgeführt, wenn weitere Rückrufe verarbeitet werden müssen. Wenn das Codeskript beendet ist oder keine Rückrufe mehr zur Verarbeitung übrig sind, wird die Ereignisschleife effizient beendet.

Nachdem wir nun die Ereignisschleife genau verstanden haben, werfen wir einen Blick auf ihre Funktionen.

Funktionen der Ereignisschleife in Node.js

Die Hauptmerkmale sind:

• Die Ereignisschleife ist eine Endlosschleife und führt die Aufgaben weiter aus, sobald sie diese erhalten. Falls keine Aufgaben vorhanden sind, geht sie in den Schlafmodus, beginnt jedoch zu funktionieren, sobald die Aufgabe empfangen wird.
• Die Aufgaben in der Ereigniswarteschlange werden nur ausgeführt, wenn der Stapel leer ist, d. h. es gibt keinen aktiven Vorgang.
• Rückrufe und Versprechen können in der Ereignisschleife verwendet werden.
• Da die Ereignisschleife dem Prinzip der Warteschlange für abstrakte Datentypen folgt, erfüllt sie die erste Aufgabe und fährt dann mit der nächsten fort.

Nach einem gründlichen Verständnis der Ereignisschleife und der Logik asynchroner und synchroner Ausführungen kann ein Verständnis der verschiedenen Phasen die Konzepte der Ereignisschleife festigen.

Phasen der Node.js-Ereignisschleife

Wie oben erwähnt, ist die Ereignisschleife halbunendlich. Es besteht aus vielen Phasen, einige Phasen dienen jedoch der internen Bearbeitung. Diese Phasen haben keine Auswirkungen auf das Codeskript.

Die Ereignisschleife folgt der Funktionalität von Queue und führt die Aufgabe nach dem First-in-First-out-Prinzip aus. Die geplanten Timer werden vom Betriebssystem verwaltet, bis sie ablaufen. Die abgelaufenen Timer werden dann zur Rückrufwarteschlange für Timer hinzugefügt.

Die Ereignisschleife führt die Aufgaben in der Timer-Warteschlange nacheinander aus, bis keine Aufgaben mehr übrig sind oder die maximal zulässige Anzahl an Aufgaben erreicht ist. In den folgenden Abschnitten werden die Kernphasen von Ereignisschleifen erläutert.

Timer-Phase

In Node.js gibt es eine Timer-API, die die Funktionen planen kann, die in Zukunft ausgeführt werden sollen. Nachdem die zugewiesene Zeit abgelaufen ist, wird der Timer-Rückruf ausgeführt, sobald er geplant werden kann; Allerdings kann es entweder seitens des Betriebssystems oder aufgrund der Ausführung anderer Rückrufe zu Verzögerungen kommen.

Die Timer-API hat drei Hauptfunktionen:

• setTimeout
• setImmediate
• setInterval

Die oben genannten Funktionen sind synchron. Der Umfang der Timer-Phase in der Ereignisschleife ist auf die Funktionen setTimeout und setInterval beschränkt. Während die Prüffunktion die setImmediate-Funktion verarbeitet.

Betrachten wir ein einfaches Beispiel, um den theoretischen Teil zu festigen:

In diesem Code:

• Das Programm startet, indem es die Anweisung „Start of the Program“ im Terminal protokolliert.
• Dann wird die verzögerte Funktion mit einem Timer von 2 ms aufgerufen, das Codeskript hält nicht an und verarbeitet die Verzögerung im Hintergrund weiter.
• Nach der ersten Anweisung wird die Anweisung „Ende des Programms“ protokolliert.
• Nach einer Verzögerung von 2 ms wird die Anweisung in der verzögerten Funktion im Terminal protokolliert.

Ausgabe

Die Ausgabe wird wie folgt angezeigt:

Es ist ersichtlich, dass der Code nicht angehalten wird, damit die verzögerte Funktion verarbeitet werden kann. es geht vorwärts und nach der Verzögerung wird der Funktionsrückruf verarbeitet.

Ausstehende Rückrufe

Die Ereignisschleife prüft, ob in der Abfragephase Ereignisse eintreten, z. B. das Lesen von Dateien, Netzwerkaktivitäten oder Eingabe-/Ausgabeaufgaben. Es ist wichtig zu wissen, dass in Node.js nur einige der Ereignisse in dieser Abfragephase verarbeitet werden. In der nachfolgenden Iteration der Ereignisschleife können jedoch bestimmte Ereignisse in die ausstehende Phase verschoben werden. Dies ist ein Schlüsselkonzept, das Sie bei der Optimierung und Fehlerbehebung von Node.js-Code berücksichtigen sollten, der komplexe ereignisgesteuerte Vorgänge umfasst.

Es ist wichtig zu verstehen, dass die Ereignisschleife während der Phase des Wartens auf Rückrufe verschobene Ereignisse zur Warteschlange ausstehender Rückrufe hinzufügt und diese ausführt. In dieser Phase werden auch einige vom System generierte TCP-Socket-Fehler behandelt, z. B. ECONNREFUSED-Fehlerereignisse auf bestimmten Betriebssystemen.

Nachfolgend wird ein Beispiel genannt, um das Konzept zu verdeutlichen:

In diesem Code:

• Der Programmstart erfolgt durch Protokollierung der Anweisung „Start of the Program“ im Terminal.
• Das readFileAsync wird asynchron definiert, um den Inhalt der Datei „PromiseText.txt“ zu lesen. Es handelt sich um eine parametrisierte Funktion, die nach dem Lesen der Datei eine Rückruffunktion ausführt.
• Die Funktion readFileAsync wird aufgerufen, um den Prozess des Dateilesens zu starten.
• Beim Lesen der Datei wird das Programm nicht angehalten; Stattdessen geht es zur nächsten Anweisung über und protokolliert sie im Terminal „Ende des Programms“.
• Das asynchrone Ereignis des Dateilesens wird im Hintergrund von der Ereignisschleife verarbeitet.
• Nachdem die Datei asynchron gelesen und der Inhalt am Terminal protokolliert wurde, protokolliert das Programm den Dateiinhalt am Terminal. Danach wird die folgende Meldung protokolliert: „Rückruf zum Lesen der Datei ausgeführt“.
• Die Ereignisschleife verarbeitet die ausstehenden Rückrufvorgänge in der nächsten Phase.

Ausgabe

Das Ergebnis der obigen Ausführung ist:

Leerlauf, Vorbereitungsphase in Node.js

Die Leerlaufphase wird zur Bearbeitung interner Funktionen in Node.js verwendet und ist daher keine Standardphase. Es hat keinen Einfluss auf das Codeskript. Die Leerlaufphase ist wie eine Pausenzeit für die Ereignisschleife, in der die Aufgaben mit niedriger Priorität im Hintergrund verwaltet werden. Ein einfaches Beispiel zum Verständnis dieser Phase ist:

In diesem Code wird das Modul „idle-gc“ verwendet, das es ermöglicht, die Leerlaufphase zu ignorieren. Dies dient dazu, Situationen zu bewältigen, in denen die Ereignisschleife ausgelastet ist und keine Hintergrundaufgaben ausgeführt werden. Die Verwendung von „idle.ignore“ wird nicht als optimal angesehen, da es zu Leistungsproblemen führen kann.

Abfragephase in Node.js

Die Umfragephase in Node.js dient als:

• Es verarbeitet die Ereignisse in der Poll-Warteschlange und führt die entsprechenden Aufgaben aus.
• Es entscheidet, wie viel Zeit mit dem Warten und Prüfen auf die E/A-Vorgänge im Prozess verbracht wird.

Wenn die Ereignisschleife aufgrund des Fehlens eines Timers in die Abfragephase eintritt, wird eine der folgenden Aufgaben ausgeführt:

• In der Poll-Phase der Event-Schleife in Node.js werden die anstehenden I/O-Events in die Warteschlange gestellt und dann in einem sequentiellen Verfahren nach dem Prinzip „First In und First Out“ ausgeführt, bis die Warteschlange leer ist. Während der Rückrufausführung sind auch die NextTick- und Microtasks-Warteschlangen in Aktion. Dies sorgt für einen reibungslosen Ablauf und ermöglicht eine effizientere und zuverlässigere Abwicklung von I/O-Vorgängen.
• Wenn die Warteschlange leer ist und das Skript nicht von der Funktion setImmediate() geplant wurde, wird die Ereignisschleife beendet und mit der nächsten Phase (Überprüfung) fortgefahren. Wenn andererseits die Skriptplanung durch die Funktion setImmediate() erfolgt ist, ermöglicht die Ereignisschleife das Hinzufügen der Rückrufe zur Warteschlange, die von ihr ausgeführt werden.

Dies lässt sich am besten anhand eines einfachen Codebeispiels veranschaulichen:

In diesem Code:

• Zwei Meldungen „Start“ und „Ende“ zeigen den Beginn und die Beendigung des Programms an.
• Die Funktion setTimeout() setzt eine Rückruffunktion mit einer Verzögerung von 2 ms und protokolliert „Async-Vorgang abgeschlossen“ am Terminal.
• Die Funktion setImmediate() protokolliert die Meldung „setImmediate-Rückruf ausgeführt“ am Terminal, nachdem die Startmeldung am Terminal protokolliert wurde.

Ausgabe

Die Ausgabe würde die Meldungen mit nur einer winzigen Beobachtung anzeigen, dass der „Async-Vorgang abgeschlossen“ Zeit braucht und nach der „Ende“-Meldung gedruckt wird:

Node.js-Prüfphase

Nachdem die Poll-Phase ausgeführt wurde, werden die Callbacks in der Check-Phase ausgeführt. Wenn ein Codeskript mit der Funktion setImmediate() geplant wird und die Poll-Funktion kostenlos ist, funktioniert die Ereignisschleife, indem sie direkt zur Prüfphase übergeht, anstatt im Leerlauf zu bleiben. Die Funktion setImmediate() ist ein einzigartiger Timer, der während der verschiedenen Phasen der Ereignisschleife arbeitet.

Die libuv-API wird verwendet, um die Rückrufausführungen zu planen, nachdem die Ausführung der Abfragephase abgeschlossen wurde. Während der Codeausführung tritt die Ereignisschleife in die Poll-Phase ein, in der sie auf die eingehenden Verbindungsanfragen wartet. In einem anderen Fall, wenn der Rückruf mit der Funktion setImmediate() geplant ist und die Abfragephase ohne jegliche Aktivität beendet wird, wird in die Prüfphase übergegangen, anstatt zu warten. Betrachten Sie zum Verständnis das folgende Beispiel:

In diesem Code werden drei Nachrichten am Terminal angemeldet. Die Funktion setImmediate() sendet dann schließlich einen Rückruf, um die Meldung „ Sofortiger Rückruf ” zum Terminal.

Ausgabe

Die Ausgabe des obigen Codes wird in der folgenden Reihenfolge angezeigt:

Node.js schließen Rückrufe

Node.js nutzt diese Schließphase, um Rückrufe auszuführen, um Ereignisse zu schließen und eine Ereignisschleifeniteration zu beenden. Nachdem die Verbindung geschlossen wurde, verarbeitet die Ereignisschleife in dieser Phase die schließenden Ereignisse. In dieser Phase der Ereignisschleife werden „nextTick()“ und Mikrotasks ähnlich wie in anderen Phasen generiert und verarbeitet.

Mit der Funktion „process.exit“ kann die Ereignisschleife jederzeit beendet werden. Die Ereignisschleife ignoriert alle ausstehenden asynchronen Vorgänge und der Node.js-Prozess wird beendet.

Ein einfaches zu berücksichtigendes Beispiel ist:

In diesem Code:

• „ const net = require(‘net’) ” importiert das Netzmodul, das für die Verwaltung eines TCP-Servers erforderlich ist, und „ const server = net.createServer((socket) => { „erstellt eine neue TCP-Serverinstanz.
• „ socket.on(‘close’, () => {… } „hört auf das „Schließen“ aller Steckdosen. Wenn die Socket-Verbindung geschlossen wird, wird die Meldung „Socket Closed“ im Terminal protokolliert.
• „ socket.on('data', (data) => {} „Prüft, ob von allen einzelnen Sockets eingehende Daten vorliegen, und gibt diese mit der Funktion „.toString()“ aus.
• „ server.on(‘close’, () => {…} „Prüft, ob das „close“-Ereignis auf dem Server selbst vorliegt, und wenn die Serververbindung geschlossen wird, protokolliert es die „Server Closed“-Meldung im Terminal.
• „ server.listen(port, () => {…} „hört auf eingehende Verbindungen am Port.
• „ setTimeout(() => {…} ” legt einen Timer von 10 ms fest, um den Server zu schließen.

Damit ist die Diskussion über die verschiedenen Phasen der Ereignisschleife in Node.js abgeschlossen. Bevor wir zu einer voreiligen Schlussfolgerung kommen, wollen wir noch eine letzte Sache besprechen, nämlich wie man die Ereignisschleife in Node.js verlässt.

Beenden der Ereignisschleife in Node.js

Die Ereignisschleife befindet sich in der Ausführungsphase, solange sich in allen Warteschlangen der Ereignisschleifenphasen einige Aufgaben befinden. Die Ereignisschleife endet, nachdem die Exit-Phase ausgegeben wurde, und der Exit-Listener-Rückruf kehrt zurück, wenn sich keine weiteren Aufgaben in den Warteschlangen befinden.

Die explizite Möglichkeit, eine Ereignisschleife zu beenden, ist die Verwendung der Methode „.exit“. Die aktiven Prozesse des Node.js werden sofort beendet, sobald die Funktion „process.exit“ aufgerufen wird. Alle geplanten und ausstehenden Veranstaltungen werden gelöscht:

Benutzer können sich die .exit-Funktion anhören. Es ist zu beachten, dass die Funktion „.exit“ synchron sein muss, da das Node.js-Programm beendet wird, sobald es auf dieses Ereignis lauscht.

Damit ist die Diskussion über die Ereignisschleife abgeschlossen. Ein ausführlicher Artikel, der alle Konzepte, Phasen und Beispiele im Zusammenhang mit der Ereignisschleife behandelt.

Abschluss

Bevor Sie die Ereignisschleife verstehen, kann ein Überblick über die synchronen und asynchronen Konzepte helfen, den Codefluss in der Ereignisschleife zu verstehen. Bei der synchronen Ausführung handelt es sich um eine schrittweise Ausführung, bei der asynchronen Ausführung um das Anhalten einiger Schritte, ohne auf deren Abschluss zu warten. Die Funktionsweise der Ereignisschleife samt aller Phasen sowie passende Beispiele werden im Artikel besprochen.