Ereignisschleife in Node.js: Asynchrone Vorgänge verwalten

Node.js ist für seine nicht blockierende, asynchrone Natur bekannt und die Ereignisschleife ist der Kern dieses Verhaltens. Dadurch wird sichergestellt, dass der Hauptthread nicht blockiert bleibt, sodass mehrere Vorgänge effizient ausgeführt werden können, ohne auf den Abschluss des anderen warten zu müssen. In diesem Artikel untersuchen wir, wie die Ereignisschleife funktioniert, unterteilen ihre sechs Phasen und diskutieren Strategien, um eine Blockierung zu verhindern.

Die Ereignisschleife in Node.js verstehen

Die Ereignisschleife in Node.js ermöglicht eine asynchrone Verarbeitung und vermeidet so die Blockierung des Hauptthreads. Es funktioniert in sechs Phasen:

Verstehen der Ereignisschleife in Node.js

Die Ereignisschleife ist ein Mechanismus, der für die Verarbeitung asynchroner Vorgänge verantwortlich ist. Immer wenn eine Operation wie E/A oder ein Timer abgeschlossen wird, bestimmt die Ereignisschleife, wann der Rückruf für diese Operation ausgeführt werden soll. Dieses Design ermöglicht es Node.js, mehrere Anfragen zu verarbeiten, ohne den Hauptthread zu blockieren, wodurch eine hohe Leistung in Anwendungen gewährleistet wird.

Die sechs Phasen der Ereignisschleife

Die Ereignisschleife arbeitet zyklisch und durchläuft sechs verschiedene Phasen. Jede Phase hat einen bestimmten Zweck und Rückrufe werden entsprechend ausgeführt.

1. Timer-Phase

In dieser Phase werden von setTimeout und setInterval geplante Rückrufe ausgeführt. Ist die angegebene Zeitverzögerung abgelaufen, läuft hier der zugehörige Callback.

Beispiel:

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

Ausgabe:

Timer scheduled.
Executed after 1 second.

Auch wenn die Verzögerung 1000 ms beträgt, wird setTimeout ausgeführt, nachdem der aktuelle Ereignisschleifen-Tick abgeschlossen ist.

Beispiel für setInterval

let count = 0;
const intervalId = setInterval(() => {
  console.log(`Interval executed: ${++count}`);
  if (count === 3) clearInterval(intervalId);
}, 500);

2. Ausstehende Rückrufphase

In dieser Phase verarbeitet die Ereignisschleife E/A-Rückrufe, die aus dem vorherigen Zyklus zurückgestellt wurden. Diese Rückrufe behandeln Fehler und nicht blockierende E/A-Vorgänge.

Beispiel:

const fs = require('fs');
fs.readFile('file.txt', (err, data) => {
  if (err) console.error(err);
  else console.log(data.toString());
});

Ausgabe:

Read operation scheduled.
File content:<contents of example.txt>
</contents>

3. Leerlauf, Vorbereitungsphase

Diese Phase wird intern von Node.js verwendet, um das System auf die nächste Abfragerunde vorzubereiten. Sie werden in dieser Phase nicht direkt interagieren, aber wir können einige damit verbundene Verhaltensweisen simulieren, indem wir uns auf Aufgaben wie die Einrichtung der internen Umfrage konzentrieren.

Beispiel mit TCP-Server-Setup (Status vorbereiten)

const net = require('net');
const server = net.createServer((socket) => {
  socket.end('Connection closed.');
});

server.listen(8080, () => {
  console.log('Server listening on port 8080.');
});

Die Vorbereitungsphase initialisiert diesen Server. Sobald es vorbereitet ist, geht es in die Abfragephase über und wartet auf eingehende Verbindungen.

4. Umfragephase

Während der Poll-Phase wartet die Ereignisschleife auf neue I/O-Ereignisse und führt die entsprechenden Rückrufe aus. Wenn keine Ereignisse anstehen, bleibt es in dieser Phase, bis ein neues Ereignis auftritt oder ein Timer zur Ausführung bereit ist.

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

Hier tritt der Server in die Abfragephase ein und wartet auf HTTP-Anfragen. Wenn eine Anfrage eintrifft, wird ihr Rückruf ausgeführt und eine Antwort gesendet.

5. Prüfphase

In der Phase Prüfung werden mit setImmediate geplante Rückrufe ausgeführt. Diese Rückrufe werden nach der Poll-Phase ausgeführt, unabhängig davon, ob E/A-Vorgänge ausstehen.

Beispiel:

Timer scheduled.
Executed after 1 second.

Ausgabe:

let count = 0;
const intervalId = setInterval(() => {
  console.log(`Interval executed: ${++count}`);
  if (count === 3) clearInterval(intervalId);
}, 500);

6. Rückrufphase schließen

In dieser Phase werden Bereinigungsvorgänge durchgeführt. Hier werden beispielsweise Rückrufe ausgeführt, die mit dem Schließen von Netzwerkverbindungen verbunden sind, wie z. B. socket.on('close').

const fs = require('fs');
fs.readFile('file.txt', (err, data) => {
  if (err) console.error(err);
  else console.log(data.toString());
});

Ausgabe:

Read operation scheduled.
File content:<contents of example.txt>
</contents>

Wenn der Client die Verbindung trennt, wird der socket.on('close')-Callback in der Close-Callbacks-Phase ausgeführt.

Blockieren der Ereignisschleife

Während die Ereignisschleife darauf ausgelegt ist, asynchrone Vorgänge effizient zu verwalten, kann das Blockieren der Schleife die Leistung beeinträchtigen. Wenn der Hauptthread bei umfangreichen Berechnungen oder synchronen Vorgängen hängen bleibt, verhindert er die Ausführung anderer Rückrufe. Dies kann zu Verzögerungen führen und dazu führen, dass Ihre Anwendung nicht mehr reagiert.

Wenn Sie CPU-intensive Aufgaben (wie große Berechnungen) im Hauptthread ausführen, blockiert dies die Ereignisschleife. So können Sie Worker-Threads verwenden, um Blockierungen zu verhindern.

Beispiel für das Blockieren der Ereignisschleife

const net = require('net');
const server = net.createServer((socket) => {
  socket.end('Connection closed.');
});

server.listen(8080, () => {
  console.log('Server listening on port 8080.');
});

Ausgabe:

const http = require('http');

const server = http.createServer((req, res) => {
  res.end('Hello from server!');
});

server.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

In diesem Beispiel kann während des 5-sekündigen Blockierungszeitraums nichts anderes ausgeführt werden, sodass die Anwendung nicht reagiert.

Lösung: Worker-Threads verwenden

setImmediate(() => {
  console.log('Executed in check phase.');
});

setTimeout(() => {
  console.log('Executed in timers phase.');
}, 0);

console.log('Main code executed.');

Ausgabe:

Main code executed.
Executed in check phase.
Executed in timers phase.

Hier läuft die Blockierungsberechnung in einem separaten Thread, sodass die Ereignisschleife frei bleibt, um andere Aufgaben zu erledigen.

So vermeiden Sie das Blockieren der Ereignisschleife

Verwenden Sie Worker-Threads für CPU-intensive Aufgaben:

Node.js stellt das Modul Worker Threads bereit, um Aufgaben wie Bildverarbeitung, Verschlüsselung oder komplexe Berechnungen zu erledigen. Dies ermöglicht die parallele Ausführung schwerer Vorgänge und entlastet die Ereignisschleife.

Beispiel eines Worker-Threads:

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

Große Aufgaben in kleinere Teile aufteilen:

Verwenden Sie asynchrone Funktionen oder setImmediate, um eine große Aufgabe in kleinere, nicht blockierende Vorgänge aufzuteilen.

Beispiel:

Timer scheduled.
Executed after 1 second.

Fazit

Die Ereignisschleife ist eine Kernkomponente von Node.js und verantwortlich für die effiziente Verwaltung asynchroner Vorgänge. Durch das Verständnis der sechs Phasen – Timer, ausstehende Rückrufe, Leerlauf und Vorbereitung, Abfrage, Prüfung und Rückrufe schließen – können Entwickler nicht blockierenden Code schreiben, der reibungslos funktioniert. Es ist jedoch wichtig, ein Blockieren der Ereignisschleife durch umfangreiche Berechnungen zu vermeiden. Der Einsatz von Tools wie Worker Threads stellt sicher, dass Ihre Anwendung schnell und reaktionsfähig bleibt. Wenn Sie die Ereignisschleife beherrschen, können Sie skalierbare und leistungsstarke Node.js-Anwendungen erstellen.

Das obige ist der detaillierte Inhalt vonEreignisschleife in Node.js: Asynchrone Vorgänge verwalten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!