gebeurtenislus in knooppunt js

Hoewel Javascript een single-threaded taal is, kan Node.js taken aan het besturingssysteem toewijzen, waardoor het meerdere taken tegelijkertijd kan verwerken. Verschillende taken moeten tegelijkertijd worden voltooid omdat bewerkingen in het besturingssysteem multi-threaded zijn. De callback die aan elke bewerking is gekoppeld, wordt toegevoegd aan de gebeurteniswachtrij en wordt door Node.js gepland om te worden uitgevoerd wanneer de opgegeven taak is voltooid.

Om efficiënte en betrouwbare Node.js-code te schrijven, moet de gebruiker een goed begrip hebben van gebeurtenislussen. Het kan ook helpen bij het effectief oplossen van prestatieproblemen. De gebeurtenislus in Node.js bespaart geheugen en stelt u in staat meerdere dingen tegelijk te doen zonder te hoeven wachten tot ze allemaal zijn voltooid. De term “asynchroon” verwijst naar elke Javascript-functie die op de achtergrond draait zonder binnenkomende verzoeken te blokkeren.

Laten we, voordat we rechtstreeks naar gebeurtenislussen springen, eens kijken naar verschillende aspecten van de Javascript-programmeertaal.

Javascript als asynchrone programmeertaal

Laten we eens kijken naar de concepten van asynchrone programmering. Javascript wordt gebruikt in web-, mobiele en desktoptoepassingen, maar er moet worden opgemerkt dat Javascript een synchrone computerprogrammeertaal met één thread is.

Er wordt een eenvoudig codevoorbeeld gegeven om het concept te begrijpen.

In deze code worden twee eenvoudige functies gemaakt en wordt eerst methode1 aangeroepen, zodat methode1 eerst wordt geregistreerd en vervolgens naar de volgende wordt verplaatst.

Uitvoer

Javascript als synchrone programmeertaal

Javascript is een synchrone programmeertaal en voert elke regel stap voor stap uit, van boven naar beneden, waarbij slechts één regel tegelijk wordt uitgevoerd. In de voorbeeldcode hierboven wordt methode1 eerst in de terminal geregistreerd en vervolgens methode2.

Javascript als blokkeertaal

Omdat het een synchrone taal is, heeft javascript een blokkerende functionaliteit. Het maakt niet uit hoe lang het duurt om een ​​lopend proces te voltooien, maar er wordt pas een nieuw proces gestart als het vorige is voltooid. Stel in het bovenstaande codevoorbeeld dat er veel codescript in methode1 zit, ongeacht hoeveel tijd het kost (10 seconden of een minuut), methode2 wordt pas uitgevoerd nadat alle code in methode1 is uitgevoerd.

Gebruikers hebben dit mogelijk ervaren tijdens het browsen. Wanneer een webapplicatie in een browser in de back-end wordt uitgevoerd, wordt er een groot deel van de code uitgevoerd, waardoor het lijkt alsof de browser enige tijd bevroren is voordat de controletoegang aan de gebruiker wordt teruggegeven. Dit gedrag staat bekend als blokkeren. De browser kan geen verdere inkomende verzoeken verwerken totdat het huidige verzoek is verwerkt.

Javascript is een taal met één thread

Om een ​​programma in javascript te laten draaien, wordt de threadfunctionaliteit gebruikt. Threads kunnen slechts één taak tegelijk uitvoeren. Andere programmeertalen ondersteunen multi-threading en kunnen meerdere taken parallel uitvoeren, javascript bevat slechts één thread voor het uitvoeren van elk codescript.

Wachten in Javascript

Zoals blijkt uit de naam in deze sectie, moeten we wachten tot ons verzoek is verwerkt voordat we verder kunnen gaan. Het wachten kan enkele minuten duren, gedurende welke geen verder verzoek wordt behandeld. Als het codescript zonder wachten verdergaat, zal de code een fout tegenkomen. Sommige functionaliteit moet worden geïmplementeerd in Javascript of meer specifiek Node.js om de code asynchroon te maken.

Nu we de verschillende aspecten van Javascript hebben begrepen, laten we synchroon en asynchroon begrijpen aan de hand van enkele eenvoudige voorbeelden.

Synchrone uitvoering van code in Javascript

Synchronisch betekent dat de code opeenvolgend of eenvoudiger stap voor stap wordt uitgevoerd, beginnend vanaf de bovenkant en regel voor regel naar beneden.

Hieronder wordt een voorbeeld gegeven dat kan helpen begrijpen:

In deze code zijn er drie console.log-instructies die elk iets afdrukken. Eerst wordt de eerste instructie die 'Eén' in de console afdrukt, gedurende 1 ms (geschat) naar de call-stack gestuurd en vervolgens naar de terminal gelogd. Daarna wordt de tweede instructie in de call-stack geduwd en nu is de tijd 2 ms, waarbij er één is toegevoegd ten opzichte van de vorige, en vervolgens wordt 'Twee' in de console geregistreerd. Ten slotte wordt de laatste instructie in de call-stack geduwd, de tijd is nu 3 ms en er wordt “Three” in de console geregistreerd.

De bovenstaande code kan worden uitgevoerd door het volgende commando aan te roepen:

Uitvoer

De werking wordt hierboven uitgebreid uitgelegd en door er rekening mee te houden wordt de output in een oogwenk in de console ingelogd:

Asynchrone uitvoering van code in Javascript

Laten we nu dezelfde code herstructureren door callbacks te introduceren en de code asynchroon te maken. De bovenstaande code kan worden geherstructureerd als:

In deze code hierboven:

• Er zijn drie functies gedeclareerd die 'Eén', 'Twee' en 'Drie' afdrukken. Elke functie heeft een callback-parameter die sequentiële uitvoering van code mogelijk maakt.
• Er wordt een time-out ingesteld met de functie setTimeout en er is een console.log-instructie voor afdrukken na een specifieke vertraging.
• Er worden twee berichten afgedrukt: “Start van het programma” en “Einde van het programma”, die het begin en het einde van het programma aangeven.
• Het programma start met het afdrukken van “Start van het programma”, waarna de functie printOne wordt uitgevoerd met een vertraging van 1 seconde, vervolgens wordt de functie printTwo uitgevoerd met een vertraging van 2 seconden en ten slotte wordt de functie printThree uitgevoerd met een vertraging van 3 seconden. vertraging.
• Het programma wacht niet op de asynchrone code-uitvoeringen binnen de setTimeouts-functies die de “End of the Program”-instructie registreren voordat Eén, Twee en Drie worden afgedrukt.

Uitvoer

Voer de bovenstaande code uit door deze opdracht in de terminal uit te voeren:

Nu zou de uitvoer in de terminal asynchroon verschijnen als:

Nu we een volledig begrip hebben van de synchrone en asynchrone uitvoering, gaan we ons concept van de gebeurtenislus in Node.js versterken.

Node.js: Event Loop-mechanisme

De uitvoering van zowel synchrone als asynchrone taken wordt beheerd door de gebeurtenislus in Node.js. De uitvoering wordt aangeroepen zodra het Node.js-project wordt gestart en brengt de complexe taken soepel over naar het systeem. Dit zorgt ervoor dat andere taken soepel op de hoofdthread kunnen worden uitgevoerd.

Visuele uitleg van Event Loop in Node.js

De gebeurtenislus is continu en semi-oneindig in Node.js. De gebeurtenislus wordt aangeroepen door het starten van het Node.js-codescript en is verantwoordelijk voor het maken van asynchrone API-aanroepen en het aanroepen van processen.Tick(), en planningstimers hervatten vervolgens de uitvoering van de gebeurtenislus.

In Node.js verwerken vijf hoofdtypen wachtrijen callbacks:

• De “Timer Queue”, algemeen bekend als een min-heap, is verantwoordelijk voor het afhandelen van callbacks die verband houden met “setTimeout” en “setInterval”.
• De callbacks voor asynchrone bewerkingen zoals in “fs” en “http” modules worden afgehandeld door “I/O Queue”.
• De “Check Queue” bevat callbacks voor de “setImmediate” -functie die uniek is voor Node.
• De “Sluitwachtrij” beheert callbacks die verband houden met de sluitingsgebeurtenis van een asynchrone taak.
• Ten slotte zijn er twee verschillende wachtrijen in de wachtrij “Micro Task”:
  • De wachtrij 'nextTick' bevat callbacks die zijn gekoppeld aan de functie 'process.nextTick'.
  • De “Promise”-wachtrij beheert callbacks gerelateerd aan native Promise.

Event Loop-functionaliteit in Node.js

De gebeurtenislus functioneert onder specifieke vereisten die de uitvoeringsvolgorde van de callback bepalen. De synchrone Javascript-code van de gebruiker krijgt prioriteit aan het begin van het proces, zodat de gebeurtenislus pas begint als de call-stack is gewist. De volgende uitvoeringsvolgorde volgt een gestructureerd patroon:

De hoogste prioriteit wordt gegeven aan de callbacks in de microtask-wachtrij en vervolgens aan het uitvoeren van de taken in de nextTick-wachtrij, gevolgd door de taken in de Promise-wachtrij. De processen in de wachtrij-callbacks van de timer worden vervolgens afgehandeld, waarna de microtask-wachtrij na elke timer-callback opnieuw wordt bezocht. De callbacks in de I/O-, check- en close-wachtrijen worden vervolgens uitgevoerd in een soortgelijk patroon waarbij de microtask-wachtrij na elke fase wordt bezocht.

De lus blijft doorgaan als er meer callbacks moeten worden verwerkt. Wanneer het codescript is beëindigd of er geen callbacks meer zijn om te verwerken, eindigt de gebeurtenislus efficiënt.

Nu we de gebeurtenislus goed begrijpen, gaan we eens kijken naar de kenmerken ervan.

Kenmerken van gebeurtenislus in Node.js

De belangrijkste kenmerken zijn:

• De gebeurtenislus is een oneindige lus en blijft de taken uitvoeren zodra hij deze ontvangt en gaat in de slaapmodus als er geen taken zijn, maar begint te functioneren zodra de taak is ontvangen.
• De taken in de gebeurteniswachtrij worden alleen uitgevoerd als de stapel leeg is, wat betekent dat er geen actieve bewerking is.
• Terugbelverzoeken en beloftes kunnen worden gebruikt in de gebeurtenislus.
• Omdat de gebeurtenislus het principe van de wachtrij van het abstracte gegevenstype volgt, vervult deze de eerste taak en gaat vervolgens door naar de volgende.

Na een grondig begrip van de gebeurtenislus en de logica van asynchrone en synchrone uitvoeringen, kan het verkrijgen van inzicht in de verschillende fasen de concepten van de gebeurtenislus versterken.

Node.js Gebeurtenislusfasen

Zoals hierboven vermeld, is de gebeurtenislus semi-oneindig. Het kent vele fasen, maar sommige fasen worden gebruikt voor interne afhandeling. Deze fasen hebben geen enkel effect op het codescript.

De gebeurtenislus volgt de functionaliteit van Queue en voert de taak uit volgens het principe van first-in en first-out. De geplande timers worden door het besturingssysteem afgehandeld totdat ze verlopen. De verlopen timers worden vervolgens toegevoegd aan de terugbelwachtrij voor timers.

De gebeurtenislus voert de taken in de wachtrij van de timer één voor één uit totdat er geen taken meer over zijn of totdat het maximaal toegestane aantal taken is bereikt. In de onderstaande paragrafen worden de kernfasen van gebeurtenislussen uitgelegd.

Timers Fase

In Node.js bevindt zich een timer-API die de functies kan plannen die in de toekomst moeten worden uitgevoerd. Nadat de toegewezen tijd is verstreken, wordt de timer-callback uitgevoerd zodra deze kan worden gepland; Er kan echter een vertraging optreden, hetzij vanuit het besturingssysteem, hetzij als gevolg van de uitvoering van andere callbacks.

De timers-API heeft drie hoofdfuncties:

• setTime-out
• stel onmiddellijk in
• setInterval

De bovengenoemde functies zijn synchroon. De timerfase in de gebeurtenislus is beperkt tot de functies setTimeout en setInterval. Terwijl de check-functie de setImmediate-functie afhandelt.

Laten we een eenvoudig voorbeeld bekijken om het theoretische gedeelte te versterken:

In deze code:

• Het programma start met het loggen van de instructie “Start of the Program” naar de terminal.
• Vervolgens wordt de delayFunction aangeroepen met een timer van 2 ms, het codescript stopt niet en gaat verder met het afhandelen van de vertraging op de achtergrond.
• De verklaring “End of the Program” wordt vastgelegd na de eerste verklaring.
• Na een vertraging van 2 ms wordt de instructie in de delayFunction naar de terminal gelogd.

Uitvoer

De uitvoer wordt weergegeven als:

Het is duidelijk dat de code niet wordt gestopt om de vertraagde functie te laten verwerken; het gaat vooruit en na de vertraging wordt de functie-callback verwerkt.

Terugbelverzoeken in behandeling

De gebeurtenislus controleert of er gebeurtenissen plaatsvinden, zoals het lezen van bestanden, netwerkactiviteiten of invoer-/uitvoertaken, in de pollingfase. Het is belangrijk om te weten dat in Node.js slechts enkele gebeurtenissen in deze pollingfase worden afgehandeld. In de daaropvolgende iteratie van de gebeurtenislus kunnen bepaalde gebeurtenissen echter worden uitgesteld naar de lopende fase. Dit is een belangrijk concept waarmee u rekening moet houden bij het optimaliseren en oplossen van problemen met Node.js-code waarbij complexe gebeurtenisgestuurde bewerkingen betrokken zijn.

Het is belangrijk om te begrijpen dat tijdens de wachtende callback-fase de gebeurtenislus uitgestelde gebeurtenissen toevoegt aan de wachtrij met openstaande callbacks en deze uitvoert. In deze fase worden ook enkele TCP-socketfouten afgehandeld die door het systeem zijn gegenereerd, zoals ECONNREFUSED-foutgebeurtenissen op bepaalde besturingssystemen.

Hieronder wordt een voorbeeld genoemd om het concept te verstevigen:

In deze code:

• Het programma wordt gestart door het loggen van de instructie “Start of the Program” in de terminal.
• De readFileAsync wordt asynchroon gedefinieerd om de inhoud van het bestand “PromiseText.txt” te lezen. Het is een geparametriseerde functie die een callback-functie uitvoert nadat het bestand is gelezen.
• De functie readFileAsync wordt aangeroepen om het proces van het lezen van bestanden te starten.
• Tijdens het lezen van bestanden stopt het programma niet; in plaats daarvan gaat het door naar de volgende verklaring en logt deze in in de terminal 'Einde van het programma'.
• De asynchrone gebeurtenis van het lezen van bestanden wordt op de achtergrond verwerkt door de gebeurtenislus.
• Nadat het bestand asynchroon is gelezen en de inhoud op de terminal is geregistreerd, registreert het programma de bestandsinhoud op de terminal. Daarna registreert het het volgende bericht 'File read callback uitgevoerd'.
• De gebeurtenislus verwerkt de openstaande callback-bewerkingen in de volgende fase.

Uitvoer

Het resultaat van de bovenstaande uitvoering is:

Inactief, fase voorbereiden in Node.js

De inactieve fase wordt gebruikt om interne functies in Node.js af te handelen, dus het is geen standaardfase. Het heeft geen invloed op het codescript. De inactieve fase is als een pauzeperiode voor de gebeurtenislus, waarin de taken met lage prioriteit op de achtergrond worden beheerd. Een eenvoudig voorbeeld om deze fase te begrijpen is:

In deze code wordt de module “idle-gc” gebruikt waarmee de inactieve fase kan worden genegeerd. Dit dient om situaties af te handelen waarin de gebeurtenislus bezet is en achtergrondtaken niet worden uitgevoerd. Het gebruik van idle.ignore wordt niet als optimaal beschouwd, omdat dit prestatieproblemen kan veroorzaken.

Pollingfase in Node.js

De poll-fase in Node.js dient als:

• Het verwerkt de gebeurtenissen in de poll-wachtrij en voert de bijbehorende taken uit.
• Het bepaalt hoeveel tijd er moet worden besteed aan het wachten en controleren op de I/O-bewerkingen in het proces.

Als de gebeurtenislus de pollfase ingaat vanwege het ontbreken van een timer, wordt een van de onderstaande taken uitgevoerd:

• In de poll-fase van de gebeurtenislus in Node.js worden de lopende I/O-gebeurtenissen in de wachtrij geplaatst en vervolgens uitgevoerd in een sequentiële procedure volgens het principe van First In en First Out totdat de wachtrij leeg raakt. Tijdens de callback-uitvoeringen zijn ook de nextTick- en microtasks-wachtrijen in actie. Dit zorgt voor soepelheid en maakt het mogelijk om I/O-bewerkingen efficiënter en betrouwbaarder af te handelen.
• Als de wachtrij leeg is en het script niet is gepland door de functie setImmediate(), dan eindigt de gebeurtenislus en gaat deze door naar de volgende fase (check). Aan de andere kant, als de scriptplanning is uitgevoerd door de setImmediate()-functie, maakt de gebeurtenislus het mogelijk dat de callbacks worden toegevoegd aan de wachtrij die erdoor wordt uitgevoerd.

Dit kan het beste worden geïllustreerd met een eenvoudig codevoorbeeld:

In deze code:

• Twee berichten “Start” en “End” geven het starten en beëindigen van het programma aan.
• De functie setTimeout() stelt een callback-functie in met een vertraging van 2 ms en registreert “Async-bewerking voltooid” naar de terminal.
• De functie setImmediate() registreert het bericht “setImmediate callback uitgevoerd” naar de terminal nadat het Start-bericht op de terminal is geregistreerd.

Uitvoer

De uitvoer toont de berichten met slechts een minuut observatie dat de “Async-bewerking voltooid” tijd kost en wordt afgedrukt na het bericht “End”:

Node.js-controlefase

Nadat de poll-fase is uitgevoerd, worden vervolgens de callbacks in de check-fase uitgevoerd. Als een codescript is gepland met behulp van de functie setImmediate() en de poll-functie vrij is, werkt de gebeurtenislus door rechtstreeks naar de controlefase te gaan in plaats van inactief te blijven. De functie setImmediate() is een unieke timer die werkt tijdens de verschillende fasen van de gebeurtenislus.

De libuv API wordt gebruikt om de callback-uitvoeringen te plannen nadat de uitvoering van de poll-fase is voltooid. Tijdens de uitvoering van de code komt de gebeurtenislus in de poll-fase terecht, waarin wordt gewacht op de binnenkomende verbindingsverzoeken. In een ander geval, als de callback is gepland met behulp van de functie setImmediate() en de poll-fase wordt beëindigd zonder enige activiteit, wordt deze naar de controlefase verplaatst in plaats van te wachten. Beschouw het onderstaande voorbeeld voor een goed begrip:

In deze code worden drie berichten ingelogd op de terminal. De functie setImmediate() verzendt vervolgens uiteindelijk een callback om het bericht “ Onmiddellijk terugbellen ' naar de terminal.

Uitvoer

De uitvoer van de bovenstaande code verschijnt in de volgende volgorde:

Node.js sluit callbacks

Node.js gebruikt deze sluitfase om callbacks uit te voeren om gebeurtenissen te sluiten en een iteratie van een gebeurtenislus te beëindigen. Nadat de verbinding is gesloten, handelt de gebeurtenislus in deze fase de afsluitende gebeurtenissen af. In deze fase van de gebeurtenislus worden “nextTick()” en microtaken gegenereerd en verwerkt op dezelfde manier als in andere fasen.

De functie process.exit wordt gebruikt om de gebeurtenislus op elk moment te beëindigen. De gebeurtenislus negeert alle lopende asynchrone bewerkingen en het Node.js-proces wordt beëindigd.

Een eenvoudig voorbeeld om te overwegen is:

In deze code:

• “ const net = vereisen(‘netto’) ” importeert de netmodule die nodig is om een ​​TCP-server te verwerken en “ const server = net.createServer((socket) => { 'maakt een nieuw TCP-serverexemplaar.
• “ socket.on(‘sluiten’, () => {… } ' luistert naar het 'sluiten' op alle stopcontacten. Wanneer de socketverbinding wordt gesloten, wordt de melding “Socket Closed” op de terminal geregistreerd.
• “ socket.on(‘gegevens’, (gegevens) => {} ” controleert op binnenkomende gegevens van alle individuele sockets en drukt deze af met behulp van de functie “.toString()”.
• “ server.on(‘sluiten’, () => {…} ” controleert op de gebeurtenis “close” op de server zelf, en wanneer de serververbinding wordt gesloten, wordt het bericht “Server Closed” bij de terminal geregistreerd.
• “ server.listen(poort, () => {…} luistert naar inkomende verbindingen op de poort.
• “ setTimeout(() => {…} ” stelt een timer in van 10 ms om de server te sluiten.

Daarmee is de discussie over de verschillende fasen van de gebeurtenislus in Node.js afgerond. Voordat we tot een conclusie komen, bespreken we nog een laatste ding: hoe we de gebeurtenislus in Node.js kunnen verlaten.

De gebeurtenislus in Node.js verlaten

De gebeurtenislus bevindt zich in de uitvoeringsfase zolang er enkele taken in alle wachtrijen van de gebeurtenislusfasen staan. De gebeurtenislus eindigt nadat de exit-fase is uitgezonden en de callback van de exit-listener keert terug als er geen taken meer in de wachtrij staan.

De expliciete manier om een ​​gebeurtenislus te beëindigen is door de “.exit”-methode te gebruiken. De actieve processen van Node.js worden onmiddellijk beëindigd zodra de functie process.exit wordt aangeroepen. Alle geplande en lopende evenementen worden verwijderd:

Gebruikers kunnen luisteren naar de .exit-functie. Opgemerkt moet worden dat de functie “.exit” synchroon moet zijn, aangezien het Node.js-programma wordt afgesloten zodra het naar deze gebeurtenis luistert.

Hiermee is de discussie over de gebeurtenislus afgerond. Een diepgaand artikel waarin alle concepten, fasen en voorbeelden met betrekking tot de gebeurtenislus zijn behandeld.

Conclusie

Voordat u de gebeurtenislus begrijpt, kan een overzicht van de synchrone en asynchrone concepten helpen de codestroom in de gebeurtenislus te begrijpen. Synchrone uitvoering betekent stapsgewijze uitvoering, terwijl asynchrone uitvoering betekent dat sommige stappen worden stopgezet zonder te wachten op de voltooiing ervan. De werking van de gebeurtenislus samen met alle fasen en geschikte voorbeelden worden in het artikel besproken.