Node JS – Die Ereignisschleife

Wir haben in unserem Artikel „Node Internals“ besprochen, warum Node JS Single-Threaded und auch Multi-Threaded ist. Es vermittelt Ihnen eine solide Grundlage für die Architektur von Node und bereitet die Grundlage für das Verständnis der Magie der Event-Schleife!

Knoten-Js könnten aufgrund der Ereignisschleife als Single-Threaded betrachtet werden. Aber was ist die Ereignisschleife?

Ich beginne immer mit der Restaurant-Analogie, weil ich denke, dass dadurch technische Details leichter zu verstehen sind.

Im Restaurant nimmt der Chefkoch also Bestellungen von der Bestellliste entgegen und gibt sie an das Assistententeam weiter. Wenn das Essen fertig ist, serviert der Koch das Essen. Wenn VIP-Kunden kommen, priorisiert der Koch diese Bestellung.

Wenn wir diese Analogie berücksichtigen, können wir sagen, dass...

Im Kontext der Node JS Event Loop.

• Chef ist die Event-Schleife, die Aufgaben verwaltet und Arbeit delegiert.

• Team of Assistance ist ein Arbeitsthread oder das Betriebssystem, das die Ausführung der ihm übertragenen Aufgaben übernimmt.

• Auftragsliste ist eine Aufgabenwarteschlange für Aufgaben, die darauf warten, an die Reihe zu kommen.

• VIP-Kunde ist eine Mikroaufgabe, die hohe Priorität hat und vor regulären Aufgaben abgeschlossen wird.

Um die Ereignisschleife zu verstehen, müssen wir zunächst den Unterschied zwischen Mikrotasks und Makrotasks verstehen.

Mikroaufgabe

Mikrotask bedeutet Aufgaben, die eine hohe Priorität haben und ausgeführt werden, nachdem der aktuell ausgeführte Javascript-Code abgeschlossen ist, aber bevor zur nächsten Phase der Ereignisschleife übergegangen wird.

Beispiel:

• process.nextTick
• Versprechen (.then, .catch, .finally)
• queueMicrotask

Makroaufgabe

Dies sind Aufgaben mit niedrigerer Priorität, die zur Ausführung in einer späteren Phase der Ereignisschleife in die Warteschlange gestellt werden.

Beispiel:

• setTimeout
• setInterval
• setImmediate
• E/A-Operationen

Die Ereignisschleife

Wenn wir asynchrone Aufgaben in Node.js ausführen, ist die Ereignisschleife das Herzstück von allem.

Dank der Ereignisschleife kann Node.js nicht blockierende E/A-Vorgänge effizient ausführen. Dies wird dadurch erreicht, dass zeitaufwändige Aufgaben an das Betriebssystem oder Arbeitsthreads delegiert werden. Sobald die Aufgaben abgeschlossen sind, werden ihre Rückrufe auf organisierte Weise verarbeitet, um eine reibungslose Ausführung ohne Blockierung des Hauptthreads zu gewährleisten.

Das ist die Magie, die es Node.js ermöglicht, mehrere Aufgaben gleichzeitig zu erledigen und dabei immer noch Single-Threaded zu sein.

Phasen

Es gibt sechs Phasen in einer Ereignisschleife und jede Phase hat ihre eigene Warteschlange, die bestimmte Arten von Aufgaben enthält.

1.Timer-Phase

In dieser Phase werden timerbezogene Rückrufe wie setTimeout und setInterval behandelt.

Node js überprüft die Timer-Warteschlange auf Rückrufe, deren Verzögerung abgelaufen ist.

Wenn eine Timer-Verzögerung erreicht ist, wird der Rückruf dieser Warteschlange zur Ausführung hinzugefügt.

console.log('Start');

setTimeout(() => {
  console.log('Timer 1 executed after 1 second');
}, 1000);

setTimeout(() => {
  console.log('Timer 2 executed after 0.5 seconds');
}, 500);

let count = 0;
const intervalId = setInterval(() => {
  console.log('Interval callback executed');
  count++;

  if (count === 3) {
    clearInterval(intervalId);
    console.log('Interval cleared');
  }
}, 1000);

console.log('End');

Ausgabe:

Start
End
Timer 2 executed after 0.5 seconds
Timer 1 executed after 1 second
Interval callback executed
Interval callback executed
Interval callback executed
Interval cleared

2.I/O-Callback-Phase

Der Zweck dieser Phase besteht darin, Rückrufe für abgeschlossene E/A-Vorgänge (Eingabe/Ausgabe) auszuführen, z. B. das Lesen oder Schreiben von Dateien, das Abfragen von Datenbanken, die Bearbeitung von Netzwerkanforderungen und andere asynchrone E/A-Aufgaben.

Wenn Sie einen asynchronen E/A-Vorgang in Node.js ausführen (z. B. das Lesen einer Datei mit fs.readFile), wird der Vorgang an das Betriebssystem oder Arbeitsthreads delegiert. Diese I/O-Aufgaben werden außerhalb des Hauptthreads auf nicht blockierende Weise ausgeführt. Sobald die Aufgabe abgeschlossen ist, wird eine Rückruffunktion ausgelöst, um die Ergebnisse zu verarbeiten.

In der E/A-Rückrufphase werden diese Rückrufe zur Ausführung in die Warteschlange gestellt, sobald der Vorgang abgeschlossen ist.

const fs = require('fs');

console.log('Start');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});

console.log('Middle');

setTimeout(() => {
  console.log('Simulated network request completed');
}, 0);

console.log('End');

Ausgabe

Start
Middle
End
Simulated network request completed
File contents: (contents of the example.txt file)

3.Leerlaufphase

In dieser Phase werden keine benutzerdefinierten Arbeiten ausgeführt, stattdessen bereitet sich die Ereignisschleife in dieser Phase auf die nächsten Phasen vor. In dieser Phase werden nur interne Anpassungen vorgenommen.

4.Umfragephase

In der Poll-Phase wird geprüft, ob ausstehende E/A-Ereignisse (z. B. Netzwerkaktivität oder Dateisystemereignisse) vorliegen, die verarbeitet werden müssen. Die mit diesen Ereignissen verbundenen Rückrufe werden sofort ausgeführt.

Wenn keine E/A-Ereignisse anstehen, kann die Poll-Phase in einen blockierenden Zustand übergehen.

In diesem Blockierungszustand wartet Node.js einfach auf das Eintreffen neuer E/A-Ereignisse. Dieser Blockierungszustand macht Node.js nicht blockierend: Es wartet, bis neue I/O-Ereignisse Callback-Ausführungen auslösen, wodurch der Hauptthread in der Zwischenzeit für andere Aufgaben frei bleibt.

Alle Rückrufe für abgeschlossene E/A-Vorgänge (z. B. fs.readFile, HTTP-Anfragen oder Datenbankabfragen) werden in dieser Phase ausgeführt. Diese E/A-Vorgänge wurden möglicherweise in früheren Phasen (wie der Timer-Phase oder der E/A-Rückrufphase) initiiert und sind nun abgeschlossen.

Wenn Timer mit setTimeout oder setInterval festgelegt sind, prüft Node.js, ob Timer abgelaufen sind und ob die zugehörigen Rückrufe ausgeführt werden müssen. Wenn die Timer abgelaufen sind, werden ihre Rückrufe in die Rückrufwarteschlange verschoben, aber erst in der nächsten Phase, der Timer-Phase, verarbeitet.

const fs = require('fs');
const https = require('https');

console.log('Start');

fs.readFile('file1.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file1:', err);
    return;
  }
  console.log('File1 content:', data);
});

fs.readFile('file2.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file2:', err);
    return;
  }
  console.log('File2 content:', data);
});

https.get('https://jsonplaceholder.typicode.com/todos/1', (response) => {
  let data = '';
  response.on('data', (chunk) => {
    data += chunk;
  });
  response.on('end', () => {
    console.log('HTTP Response:', data);
  });
});

console.log('End');

Ausgabe:

Start
End
File1 content: (contents of file1.txt)
File2 content: (contents of file2.txt)
HTTP Response: (JSON data from the HTTP request)

5.Prüfphase

Nachdem die Umfragephase ihre Aufgaben abgeschlossen hat. Diese Phase kümmert sich hauptsächlich um die Ausführung von setImmediate-Rückrufen, deren Ausführung unmittelbar nach der Verarbeitung der E/A-Ereignisse in der Poll-Phase geplant ist.

setImmediate-Rückrufe werden häufig verwendet, wenn Sie eine Aktion nach dem aktuellen Ereignisschleifenzyklus ausführen möchten, z. B. um sicherzustellen, dass eine Aufgabe ausgeführt wird, nachdem das System nicht mit der Verarbeitung von E/A-Ereignissen beschäftigt ist.

Die Check-Phase hat eine höhere Priorität als die Timer-Phase (die setTimeout und setInterval verarbeitet). Das bedeutet, dass setImmediate-Rückrufe immer vor allen Timern ausgeführt werden, auch wenn deren Timer abgelaufen sind.

setImmediate garantiert, dass sein Rückruf nach dem aktuellen E/A-Zyklus und vor dem nächsten Timer-Zyklus ausgeführt wird. Dies kann wichtig sein, wenn Sie sicherstellen möchten, dass E/A-bezogene Aufgaben zuerst abgeschlossen werden, bevor andere Aufgaben ausgeführt werden.

console.log('Start');

setTimeout(() => {
  console.log('Timer 1 executed after 1 second');
}, 1000);

setTimeout(() => {
  console.log('Timer 2 executed after 0.5 seconds');
}, 500);

let count = 0;
const intervalId = setInterval(() => {
  console.log('Interval callback executed');
  count++;

  if (count === 3) {
    clearInterval(intervalId);
    console.log('Interval cleared');
  }
}, 1000);

console.log('End');

Ausgabe:

Start
End
Timer 2 executed after 0.5 seconds
Timer 1 executed after 1 second
Interval callback executed
Interval callback executed
Interval callback executed
Interval cleared

6.Schließphase

Die Close Callbacks-Phase wird normalerweise ausgeführt, wenn eine Anwendung vor dem Beenden oder Herunterfahren bereinigt werden muss.

Diese Phase befasst sich mit Ereignissen und Aufgaben, die ausgeführt werden müssen, sobald eine Systemressource, wie ein Netzwerk-Socket oder ein Dateihandle, nicht mehr benötigt wird.

Ohne diese Phase könnte eine Anwendung offene Dateihandles, Netzwerkverbindungen oder andere Ressourcen hinterlassen, was möglicherweise zu Speicherverlusten, Datenbeschädigung oder anderen Problemen führen könnte.

const fs = require('fs');

console.log('Start');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});

console.log('Middle');

setTimeout(() => {
  console.log('Simulated network request completed');
}, 0);

console.log('End');

Ausgabe:

Start
Middle
End
Simulated network request completed
File contents: (contents of the example.txt file)

Es gibt noch eine weitere besondere Phase in der Ereignisschleife von Node JS.

Mikrotask-Warteschlange

process.nextTick() und verspricht, ihre Rückrufe in einer speziellen Phase in der Ereignisschleife auszuführen.

process.nextTick() plant einen Rückruf, der unmittelbar nach Abschluss des aktuellen Vorgangs ausgeführt wird, aber bevor die Ereignisschleife mit der nächsten Phase fortfährt.

process.nextTick() ist nicht Teil einer Phase in der Ereignisschleife. Stattdessen verfügt es über eine eigene interne Warteschlange, die direkt nach dem aktuell ausgeführten synchronen Code und vor dem Eintritt in eine Phase der Ereignisschleife ausgeführt wird.

Es wird nach dem aktuellen Vorgang, aber vor E/A, setTimeout oder anderen in der Ereignisschleife geplanten Aufgaben ausgeführt.

Versprechen haben eine niedrigere Priorität als Process.nextTick() und werden nach allen Process.nextTick()-Rückrufen verarbeitet.

const fs = require('fs');
const https = require('https');

console.log('Start');

fs.readFile('file1.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file1:', err);
    return;
  }
  console.log('File1 content:', data);
});

fs.readFile('file2.txt', 'utf8', (err, data) => {
  if (err) {
    console.log('Error reading file2:', err);
    return;
  }
  console.log('File2 content:', data);
});

https.get('https://jsonplaceholder.typicode.com/todos/1', (response) => {
  let data = '';
  response.on('data', (chunk) => {
    data += chunk;
  });
  response.on('end', () => {
    console.log('HTTP Response:', data);
  });
});

console.log('End');

Ausgabe:

Start
End
File1 content: (contents of file1.txt)
File2 content: (contents of file2.txt)
HTTP Response: (JSON data from the HTTP request)

Jetzt haben Sie eine allgemeine Vorstellung davon, wie die Ereignisschleife funktioniert.

Ich stelle dir eine Frage, die du in den Kommentaren beantworten kannst.

const fs = require('fs');

console.log('Start');

fs.readFile('somefile.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('File content:', data);
});

setImmediate(() => {
  console.log('Immediate callback executed');
});

setTimeout(() => {
  console.log('Timeout callback executed');
}, 0);

console.log('End');

Vielen Dank.

Warten auf Ihre Antwort.

Das obige ist der detaillierte Inhalt vonNode JS – Die Ereignisschleife. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!