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!