Umfassendes Verständnis der Node-Ereignisschleife
Knoten-Ereignisschleife Die zugrunde liegende Sprache von Node ist libuv , eine C++-Sprache. Es dient zum Betrieb des zugrundeliegenden Betriebssystems und kapselt die Betriebssystemschnittstelle. Die Ereignisschleife von Node ist ebenfalls in Da Node mit dem Betriebssystem arbeitet, ist die Ereignisschleife relativ komplex und verfügt über einige eigene einzigartige APIs. EreignisschleifendiagrammWie versprochen gibt es ein Bild und ich will euch nicht auf die Folter spannen. Wenn Sie das folgende Bild verstehen, haben Sie die Ereignisschleife gelernt.
Ereignisschleifendiagramm
Ereignisschleifendiagramm - Struktur Um jedem einen allgemeinen Überblick zu geben, hier ein Verzeichnisstrukturdiagramm :
Inhaltsverzeichnis Lassen Sie uns als Nächstes ausführlich darüber sprechen. Hauptthread
Hauptthread Im obigen Bild haben die einzelnen Farbblöcke folgende Bedeutung:
Ereignisschleife
Ereignisschleife Der graue Kreis in der Abbildung bezieht sich auf das Betriebssystem und ist nicht Schwerpunkt der Analyse dieses Kapitels. Achten Sie besonders auf die gelben und orangefarbenen Kreise und das orangefarbene Kästchen in der Mitte. Wir nennen jede Runde der Ereignisschleife „einen Zyklus“, auch „Umfrage“ oder „Tick“ genannt. Ein Zyklus durchläuft sechs Phasen:
Dieses Mal konzentrieren wir uns nur auf die drei oben rot markierten Schlüsselpunkte. So funktioniert es
Darunter gelangen So funktioniert die Timer-Warteschlange Timer sind keine Warteschlangen im eigentlichen Sinne, sie speichern Timer in sich. Prüfvorgang: Berechnen Sie der Reihe nach jeden Timer und berechnen Sie, ob die Zeit vom Start des Timers bis zur aktuellen Zeit der Einstellung des Timerintervallparameters entspricht (z. B. 1000 ms, berechnen Sie, ob seit dem Start des Timers 1 Minute vergangen ist). Wenn eine Timerprüfung erfolgreich ist, wird ihre Rückruffunktion ausgeführt. So funktioniert die Poll-Warteschlange
Beispiel für Ereignisfluss
setzeTimeout(() => {
konsole.log('Objekt');
}, 5000)
konsole.log('Knoten');Der Ereignisfluss des obigen Codes Betreten Sie den Hauptthread und führen Sie setTimeout() aus. Die Callback-Funktion wird als asynchrone Task in die asynchrone Warteschlange der Timer gestellt und vorerst nicht ausgeführt.
Um dieses Problem zu verstehen, sehen Sie sich den folgenden Code und die Prozessanalyse an:
setzeTimeout(Funktion t1() {
console.log('Zeitüberschreitung festlegen');
}, 5000)
console.log('Knoten-Lebenszyklus');
const http = erfordern('http').
const server = http.createServer(function h1() {
console.log('Rückruf anfordern');
});
server.listen(8080)Die Codeanalyse ist wie folgt:
Wenn sich in den sechs Warteschlangen keine Aufgaben befinden, warten sie in der Polling-Warteschlange. Wie unten dargestellt:
Endlosschleife... Sortieren des Flussdiagramms der Ereignisschleife: Hinweis: Der Begriff „Gibt es eine Aufgabe“ in der folgenden Abbildung bedeutet „Gibt es eine Aufgabe in dieser Warteschlange?“
Zusammenfassung des Ereignisschleifenprozesses Lassen Sie uns den Vorgang anhand eines typischen Beispiels überprüfen:
const startTime = neues Datum();
setzeTimeout(Funktion f1() {
console.log('setTimeout', neues Datum(), neues Datum() - Startzeit);
}, 200)
console.log('Knoten-Lebenszyklus', Startzeit);
const fs = erfordern('fs')
fs.readFile('./poll.js', 'utf-8', Funktion fsFunc(err, Daten) {
const fsTime = neues Datum()
console.log('fs', fsTime);
während (neues Datum() - fsTime < 300) {
}
console.log('Ende der Endlosschleife', neues Datum());
});Führen Sie den Vorgang dreimal hintereinander aus und drucken Sie die folgenden Ergebnisse aus:
Analyse des Ausführungsprozesses:
Nachdem Sie lange genug gewartet haben, gehen Sie zurück zur Ereignisschleife. Die Ereignisschleife prüft, ob keine anderen asynchronen Aufgaben vorhanden sind, beendet den Thread und das gesamte Programm wird beendet. PrüfphasePrüfphase (Rückrufe mit „setImmediate“ gehen direkt in diese Warteschlange) So funktioniert die Check-Warteschlange tatsächlich Die eigentliche Warteschlange enthält eine Sammlung auszuführender Rückruffunktionen. Ähnlich der Form [fn,fn]. Daher ist setImmediate kein Timer-Konzept. Wenn Sie zu einem Vorstellungsgespräch gehen und es dabei um Node geht, werden Sie möglicherweise mit der folgenden Frage konfrontiert: Was ist schneller, setImmediate oder setTimeout(0)? setImmediate() vs. setTimeout(0)
Zusammenfassend lässt sich sagen, dass setImmediate schneller arbeitet als setTimeout(0), da setTimeout auch einen Timer-Thread starten muss und den Rechenaufwand erhöht. Die Auswirkungen beider sind ähnlich. Doch die Reihenfolge der Hinrichtung ist ungewiss Beachten Sie den folgenden Code:
setzeTimeout(() => {
console.log('Zeitüberschreitung festlegen');
}, 0);
setImmediate(() => {
Konsole.log('setImmediate');
});Nach mehrmaliger Ausführung ist der Ausführungseffekt wie folgt:
Unsichere Reihenfolge Man sieht, dass die Reihenfolge der beiden console.log-Anweisungen bei mehrmaliger Ausführung nicht festgelegt ist. Im obigen Code wird, wenn der Hauptthread ausgeführt wird, die Funktion setTimeout aufgerufen und der Timer-Thread fügt eine Timer-Aufgabe hinzu. Nachdem die Funktion „setImmediate“ aufgerufen wurde, wird ihre Rückruffunktion sofort in die Prüfwarteschlange gestellt. Der Hauptthread hat die Ausführung abgeschlossen. Wenn eventloop feststellt, dass sich Inhalt in den Timern und Prüfwarteschlangen befindet, beginnt es mit der asynchronen Abfrage: Der erste Fall: Wenn die Zeit in den Timern erreicht ist, ist möglicherweise nicht mehr 1 ms übrig und die Bedingung des Timer-Task-Intervalls ist nicht erfüllt. Daher gibt es in den Timern keine Rückruffunktion. Fahren Sie mit der Überprüfungswarteschlange fort. Zu diesem Zeitpunkt wartet die Rückruffunktion von setImmediate schon lange und wird direkt ausgeführt. Wenn die Ereignisschleife das nächste Mal die Warteschlange des Timers erreicht, ist der Timer abgelaufen und die Callback-Aufgabe „setTimeout“ wird ausgeführt. Die Reihenfolge ist also „setImmediate -> setTimeout“. Der zweite Fall: Es ist aber auch möglich, dass es 1 ms überschreitet, wenn es die Timerstufe erreicht. Daher ist die Bedingung des Berechnungstimers erfüllt und die Callback-Funktion setTimeout wird direkt ausgeführt. Die Ereignisschleife geht dann zur Prüfwarteschlange, um den Rückruf von setImmediate auszuführen. Die endgültige Reihenfolge ist „setTimeout -> setImmediate“. Daher hängt das endgültige Ergebnis der Ausführungsreihenfolge der beiden Funktionen beim Vergleich nur dieser beiden Funktionen von der aktuellen Betriebsumgebung und Betriebsgeschwindigkeit des Computers ab . Vergleichscode der Zeitdifferenz zwischen den beiden
------------------setTimeout-Test:------------------
sei i = 0;
Konsole.Zeit('Zeitlimit festlegen');
Funktion test() {
wenn (i < 1000) {
setzeTimeout(test, 0)
ich++
} anders {
Konsole.timeEnd('Zeitüberschreitung festlegen');
}
}
prüfen();
------------------setImmediate-Test:------------------
sei i = 0;
Konsole.Zeit('setImmediate');
Funktion test() {
wenn (i < 1000) {
setImmediate(test)
ich++
} anders {
Konsole.timeEnd('setImmediate');
}
}
prüfen();Laufen und den Zeitabstand beachten:
Der Zeitunterschied zwischen setTimeout und setImmediate Es ist ersichtlich , dass setTimeout viel mehr Zeit benötigt als setImmediate Dies liegt daran, dass setTimeout nicht nur die Zeit der Hauptcodeausführung verbraucht. Außerdem befindet sich in der Timer-Warteschlange die Berechnungszeit für jede geplante Aufgabe im Timer-Thread. Interviewfragen im Zusammenhang mit der Polling-Warteschlange (Untersuchung der Ausführungsreihenfolge von Timern, Polling und Check) Wenn Sie das obige Ereignisschleifendiagramm verstehen, wird Ihnen die folgende Frage nicht schwer fallen!
// Besprechen Sie die Ausführungsreihenfolge des folgenden Codes. Welcher wird zuerst gedruckt?
const fs = erfordern('fs')
fs.readFile('./poll.js', () => {
setTimeout(() => console.log('setTimeout'), 0)
setImmediate(() => console.log('setImmediate'))
})Unabhängig davon, wie oft die obige Codelogik ausgeführt wird, wird setImmediate immer zuerst ausgeführt.
Führen Sie zuerst „setImmediate“ aus. Weil die Rückrufe jeder FS-Funktion in die Polling-Warteschlange gestellt werden. Wenn das Programm in der Polling-Warteschlange hängt, wird sofort ein Rückruf ausgeführt. weiterTick and PromiseNachdem wir über Makroaufgaben gesprochen haben, sprechen wir nun über Mikroaufgaben.
NextTick-Ausdruck
Prozess.nextTick(() => {})Versprechensdarstellung
Versprechen.auflösen().dann(() => {})Wie nehme ich an der Eventschleife teil? Löschen Sie in der Ereignisschleife vor der Ausführung jedes Rückrufs nacheinander „nextTick“ und „promise“.
// Betrachten Sie zuerst die Ausführungsreihenfolge des folgenden Codes setImmediate(() => {
Konsole.log('setImmediate');
});
Prozess.nextTick(() => {
console.log('nächsterTick 1');
Prozess.nextTick(() => {
console.log('nächsterTick 2');
})
})
konsole.log('global');
Versprechen.auflösen().dann(() => {
console.log('Versprechen 1');
Prozess.nextTick(() => {
console.log('nextTick im Versprechen');
})
})Endgültige Reihenfolge:
Zwei Fragen: Vor diesem Hintergrund müssen zwei Fragen berücksichtigt und gelöst werden:
Informationen zu den beiden obigen Fragen finden Sie im folgenden Code.
setzeTimeout(() => {
console.log('setTimeout 100');
setzeTimeout(() => {
console.log('setTimeout 100 - 0');
Prozess.nextTick(() => {
console.log('nextTick in setTimeout 100 - 0');
})
}, 0)
setImmediate(() => {
console.log('setImmediate in setTimeout 100');
Prozess.nextTick(() => {
console.log('nextTick in setImmediate in setTimeout 100');
})
});
Prozess.nextTick(() => {
console.log('nextTick in setTimeout100');
})
Versprechen.auflösen().dann(() => {
console.log('Versprechen in setTimeout100');
})
}, 100)
const fs = erfordern('fs')
fs.readFile('./1.poll.js', () => {
console.log('Umfrage 1');
Prozess.nextTick(() => {
console.log('nextTick in Umfrage ======');
})
})
setzeTimeout(() => {
console.log('setTimeout 0');
Prozess.nextTick(() => {
console.log('nextTick in setTimeout');
})
}, 0)
setzeTimeout(() => {
console.log('setTimeout 1');
Versprechen.auflösen().dann(() => {
console.log('Versprechen in setTimeout1');
})
Prozess.nextTick(() => {
console.log('nextTick in setTimeout1');
})
}, 1)
setImmediate(() => {
Konsole.log('setImmediate');
Prozess.nextTick(() => {
console.log('nextTick in setImmediate');
})
});
Prozess.nextTick(() => {
console.log('nächsterTick 1');
Prozess.nextTick(() => {
console.log('nextTick 2');
})
})
console.log('global ------');
Versprechen.auflösen().dann(() => {
console.log('Versprechen 1');
Prozess.nextTick(() => {
console.log('nextTick im Versprechen');
})
})
/** Die Ausführungsreihenfolge ist global wie folgt ------
nächsterTick 1
nächsterTick 2
Versprechen 1
nächstesHäkchen im Versprechen
setTimeout 0 // Erklärung des Problems 1. Ohne nextTick und Promise oben ist die Reihenfolge von setTimeout und setImmediate nicht sicher. Mit ihnen wird 0 definitiv zuerst starten.
// Es ist ersichtlich, dass vor der Ausführung einer Warteschlange zuerst die Mikrowarteschlangen nextTick und promise geprüft und ausgeführt werden. nextTick in setTimeout
setTimeout 1
nächsterTick in setTimeout1
Versprechen in setTimeout1
Sofort festlegen
nächstes Häkchen in setImmediate
Umfrage 1
nextTick in Umfrage ======
setTimeout 100
nächsterTick in setTimeout100
Versprechen in setTimeout100
setImmediate in setTimeout 100
nextTick in setImmediate in setTimeout 100
setTimeout 100 - 0
nächsterTick in setTimeout 100 - 0
*/Der obige Code wird mehrmals in derselben Reihenfolge ausgeführt und die Reihenfolge von setTimeout und setImmediate bleibt unverändert. Die Reihenfolge der Ausführung und die genauen Gründe sind wie folgt:
Erweiterung: Warum brauchen wir nextTick und Promise, wenn wir setImmediate haben? Bei seiner ersten Entwicklung fungierte setImmediate als Mikrowarteschlange (obwohl dies nicht der Fall ist). Der Designer hofft, dass setImmediate unmittelbar nach der Ausführung der Umfrage ausgeführt wird (natürlich ist dies jetzt tatsächlich der Fall). Der Name lautet So entstand nextTick, das echte Mikro-Warteschlangen-Konzept. Aber zu diesem Zeitpunkt ist der Name „immediate“ vergeben, daher lautet der Name „nextTick“ (nächster Tick). Während der Ereignisschleife wird vor der Ausführung einer Warteschlange geprüft, ob sie leer ist. Das Zweite ist „Versprechen“. Fragen im VorstellungsgesprächZum Schluss kommt noch die Interviewfrage zur Überprüfung der Lernergebnisse
asynchrone Funktion async1() {
console.log('asynchroner Start');
warte auf async2();
console.log('asynchrones Ende');
}
asynchrone Funktion async2(){
Konsole.log('async2');
}
console.log('Skriptstart');
setzeTimeout(() => {
console.log('setTimeout 0');
}, 0)
setzeTimeout(() => {
console.log('setTimeout 3');
}, 3)
setImmediate(() => {
Konsole.log('setImmediate');
})
Prozess.nextTick(() => {
console.log('nächsterTick');
})
async1();
neues Versprechen((res) => {
Konsole.log('Versprechen1');
res();
console.log('versprechen2');
}).then(() => {
console.log('Versprechen 3');
});
console.log('Skriptende');
// Die Antwort lautet wie folgt // -
// -
// -
// -
// -
// -
// -
// -
// -
// -
// -
// -
/**
Skriptstart
asynchroner Start
asynchron2
Versprechen1
Versprechen2
Skript-Ende
nächstesTick
asynchrones Ende
Versprechen 3
// Die folgenden drei Vorgänge dienen der Überprüfung der Rechengeschwindigkeit Ihres Computers.
Am schnellsten (weniger als 0 ms, um den obigen Synchronisierungscode + Mikrotask + Timervorgang auszuführen):
Sofort festlegen
setTimeout 0
setTimeout 3
Die Geschwindigkeit ist mittel (die Ausführung des obigen Synchronisierungscodes + Mikrotask + Timervorgang dauert mehr als 0 bis 3 ms):
setTimeout 0
Sofort festlegen
setTimeout 3
Schlechte Geschwindigkeit (die Ausführung des obigen Synchronisierungscodes + Mikrotask + Timervorgang dauerte mehr als 3 ms):
setTimeout 0
setTimeout 3
Sofort festlegen
*/ Mindmap Kernphasen des Node-Lebenszyklus Dies ist das Ende dieses Artikels zum umfassenden Verständnis der Node-Ereignisschleife. Weitere Informationen zur Node-Ereignisschleife finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen! Das könnte Sie auch interessieren:
|
<<: Sammlung von MySQL-Fuzzy-Abfrageanweisungen
Artikel empfehlen
Grafisches Tutorial zur Installation und Konfiguration von MySQL 5.7.24
MySQL ist das beliebteste relationale Datenbankma...
Detaillierte Erklärung der JavaScript-Array-Deduplizierung
Inhaltsverzeichnis 1. Array-Deduplizierung 2. Ded...
Tutorial zur MySQL-Installation in der Linux-CentOS7-Umgebung
Detaillierte Einführung in die Schritte zur Insta...
Web-Frontend-Entwicklung CSS-bezogene Teamzusammenarbeit
Die Frontend-Entwicklungsabteilung wächst, die Mi...
Beheben Sie das Problem, dass sich die Ränder des Suchfelds und der Suchschaltfläche nicht überlappen können
Als ich heute mit der Baidu-Seite übte, stellte i...
Fallbeispiel zur TypeScript-Schnittstellendefinition
Die Rolle der Schnittstelle: Schnittstelle, auf E...
So verwenden Sie Shell-Skripte in Node
Hintergrund Während der Entwicklung benötigen wir...
Verschachtelte Verwendungsoperation für MySQL-Aggregatfunktionen
Zweck: Verschachtelte Verwendung von MySQL-Aggreg...
Detaillierte Erläuterung der Ausführungsreihenfolge der JavaScript-Alarmfunktion
Inhaltsverzeichnis Frage analysieren lösen Ersetz...
Lösen Sie das Problem, dass der Standardwert des CSS3-Übergangsverzögerungsattributs 0 ohne Einheit ist und ungültig ist
Heute möchte ich mit Ihnen teilen, dass der Stand...
Implementierungsbeispiel für die Bereitstellung von Docker rocketmq
Inhaltsverzeichnis Vorbereitung Bereitstellungspr...
Schritte zum Installieren einer RocketMQ-Instanz unter Linux
1. JDK installieren 1.1 Überprüfen Sie, ob die ak...
Details zur Verwendung der JS-Tag-Syntax
Inhaltsverzeichnis 1. Einführung in Label-Anweisu...
Beispielcode zum Setzen von Hotlinks und Koordinatenwerten für Webbilder
Manchmal müssen Sie mehrere Bereiche auf einem Bi...
Analyse des Konfigurationsprozesses zur Installation von MariaDB basierend auf Docker
1. Installation Suchen Sie über DockerHub nach de...