eseményhurok a js csomópontban

Bár a Javascript egyszálú nyelv, a Node.js feladatokat rendelhet az operációs rendszerhez, így több feladat egyidejű feldolgozását is lehetővé teszi. Egyszerre több feladatot is el kell végezni, mert az operációs rendszerben a műveletek többszálúak. Az egyes műveletekhez társított visszahívások hozzáadódnak az eseménysorhoz, és a Node.js ütemezi a futtatásra, amikor a megadott feladat befejeződött.

A hatékony és megbízható Node.js kód írásához a felhasználónak alaposan ismernie kell az eseményhurkokat. A teljesítményproblémák hatékony elhárításában is segíthet. A Node.js eseményhuroka memóriát takarít meg, és lehetővé teszi, hogy egyszerre több dolgot is elvégezzen anélkül, hogy meg kellene várnia, amíg mindegyik befejeződik. Az „aszinkron” kifejezés minden olyan Javascript-funkcióra utal, amely a háttérben fut anélkül, hogy blokkolná a bejövő kéréseket.

Mielőtt közvetlenül az eseményhurkokra ugrunk, vessünk egy pillantást a Javascript programozási nyelv különböző aspektusaira.

Javascript, mint aszinkron programozási nyelv

Vessünk egy pillantást az aszinkron programozás fogalmaira. A Javascriptet webes, mobil- és asztali alkalmazásokban használják, de meg kell jegyezni, hogy a Javascript egy egyszálú, szinkron számítógépes programozási nyelv.

A fogalom megértéséhez egy egyszerű kódpéldát adunk.

Ebben a kódban két egyszerű függvény jön létre, és először a method1-et hívják meg, így először a method1-et naplózza, majd a következőre lép.

Kimenet

Javascript, mint szinkron programozási nyelv

A Javascript egy szinkron programozási nyelv, és minden sort lépésről lépésre hajt végre, felülről lefelé haladva, egyszerre csak egy sor végrehajtásával. A fenti példakódban először a metódus1 kerül naplózásra a terminálba, majd a method2.

Javascript mint blokkoló nyelv

Szinkron nyelvként a javascript blokkoló funkcióval rendelkezik. Nem számít, mennyi ideig tart egy folyamatban lévő folyamat befejezése, de egy új folyamat nem indul el, amíg az előző be nem fejeződik. A fenti kódpéldában tegyük fel, hogy sok kódszkript van az 1-es metódusban, függetlenül attól, hogy mennyi időbe telik 10 másodpercig vagy egy percig.

A felhasználók ezt tapasztalhatták böngészés közben. Amikor egy webalkalmazás a háttérben lévő böngészőben fut, hatalmas kóddarabot hajtanak végre, így a böngésző lefagyottnak tűnik egy ideig, mielőtt visszaadná a vezérlő hozzáférést a felhasználónak. Ezt a viselkedést blokkolásnak nevezik. A böngésző nem tud további bejövő kéréseket fogadni, amíg az aktuális kérés feldolgozása meg nem történt.

A Javascript egyszálú nyelv

A program javascriptben való futtatásához a szál funkciót kell használni. A szálak egyszerre csak egy feladat végrehajtására képesek. Más programozási nyelvek támogatják a több szálat, és több feladatot is futtathatnak párhuzamosan, a javascript csak egy szálat tartalmaz bármely kódszkript végrehajtásához.

Várakozás a Javascriptben

Amint az ebben a részben szereplő névből is kitűnik, a további folytatáshoz meg kell várnunk kérésünk feldolgozását. A várakozás több percig is eltarthat, amely alatt nem fogadunk el további kérést. Ha a kódszkript várakozás nélkül halad tovább, akkor a kód hibába ütközik. Néhány funkciót Javascriptben vagy pontosabban a Node.js-ben kell megvalósítani, hogy a kód aszinkron legyen.

Most, hogy megértettük a Javascript különböző aspektusait, néhány egyszerű példán keresztül értsük meg a szinkront és az aszinkront.

Kód szinkron végrehajtása Javascriptben

A szinkron azt jelenti, hogy a kódot szekvenciálisan vagy egyszerűbben lépésről lépésre hajtják végre felülről kezdve és soronként lefelé haladva.

Az alábbiakban egy példa látható, amely segíthet megérteni:

Ebben a kódban három console.log utasítás található, amelyek mindegyike nyomtat valamit. Először az első utasítás, amely a konzolban „Egyet” fog kiírni, a hívási verembe kerül 1 ms-ig (becsült érték), majd naplózásra kerül a terminálon. Ezt követően a második utasítás bekerül a hívási verembe, és most 2 ms az idő, hozzáadva egyet az előzőből, majd naplózza a „Two”-t a konzolra. Végül az utolsó utasítás bekerül a hívási verembe, az idő jelenleg 3 ms, és a konzolban naplózza a „Három” értéket.

A fenti kód a következő parancs meghívásával hajtható végre:

Kimenet

A működést fent részletesen ismertetjük, és ennek figyelembevételével a kimenet egy szempillantás alatt bejelentkezik a konzolba:

Kód aszinkron végrehajtása Javascriptben

Most újra faktoráljuk ugyanazt a kódot visszahívások bevezetésével és a kód aszinkronizálásával. A fenti kód a következőképpen alakítható át:

Ebben a fenti kódban:

• Három függvény van deklarálva az „Egy”, „Kettő” és „Három” nyomtatására, mindegyik függvénynek van egy visszahívási paramétere, amely lehetővé teszi a kód szekvenciális végrehajtását.
• Az időtúllépés a setTimeout függvénnyel van beállítva, és van egy console.log utasítás a nyomtatáshoz egy meghatározott késleltetés után.
• Két üzenet kerül kinyomtatásra: „Start of the Program” és „End of the Program”, amelyek jelzik a program kezdetét és végét.
• A program a „Program indítása” kinyomtatásával indul, amely után a printOne funkció 1 másodperces késleltetéssel, majd a printTwo funkció 2 másodperces késleltetéssel, végül a printThree funkció 3 másodperces késleltetéssel. késleltetés.
• A program nem várja meg az aszinkron kódvégrehajtásokat a setTimeouts függvényeken belül, amelyek naplózza a „Program vége” utasítást, mielőtt kinyomtatja az Egy, a Kettő és a Három.

Kimenet

Futtassa a fenti kódot a következő parancs végrehajtásával a terminálban:

Most a terminál kimenete aszinkron módon jelenne meg:

Most, hogy teljes mértékben megértjük a szinkron és aszinkron végrehajtást, ugorjunk az eseményhurok koncepciójának megszilárdítására a Node.js-ben.

Node.js: Eseményhurok-mechanizmus

Mind a szinkron, mind az aszinkron feladatok végrehajtását a Node.js eseményhuroka kezeli. A végrehajtás a Node.js projekt indulásakor azonnal meghívásra kerül, és zökkenőmentesen továbbítja az összetett feladatokat a rendszernek. Ez biztosítja, hogy a többi feladat zökkenőmentesen futhasson a főszálon.

Az eseményhurok vizuális magyarázata a Node.js-ben

Az eseményhurok folyamatos és félig végtelen a Node.js-ben. Az eseményhurkot a Node.js kódszkript indítása hívja meg, és ez felelős az aszinkron API-hívásokért és a folyamatok hívásáért. A Tick() és az időzítők ütemezése ezután folytatja az eseményhurok végrehajtását.

A Node.js-ben öt fő sortípus kezeli a visszahívásokat:

• A „Timer Queue”, közismertebb nevén min-heap, a „setTimeout” és a „setInterval”-hoz kapcsolódó visszahívások kezeléséért felelős.
• Az „fs” és „http” modulokhoz hasonló aszinkron műveletek visszahívásait az „I/O Queue” kezeli.
• A „Check Queue” visszahívásokat tartalmaz a „setImmediate” funkcióhoz, amely egyedi a Node-ra.
• A „Close Queue” kezeli az aszinkron feladat záróeseményéhez kapcsolódó visszahívásokat.
• Végül két különböző sor van a „Mikrofeladat” várólista:
  • A „nextTick” sor a „process.nextTick” függvényhez társított visszahívásokat tartalmazza.
  • Az „Promise” sor vezérli a natív Promise-hoz kapcsolódó visszahívásokat.

Event Loop funkció a Node.js-ben

Az eseményhurok meghatározott követelmények szerint működik, amelyek szabályozzák a visszahívási végrehajtási sorrendet. A felhasználó szinkron Javascript kódja elsőbbséget élvez a folyamat elején, így az eseményhurok csak akkor indul el, ha a hívási verem törlődik. A következő végrehajtási szekvencia strukturált mintát követ:

A legmagasabb prioritást a microtask sorban lévő visszahívások kapják, majd a nextTick sorban lévő feladatok végrehajtására költöznek, ezt követik a Promise sorban lévő feladatok. Az időzítő várólista visszahívásaiban lévő folyamatokat ezután kezeli, majd minden egyes időzítő visszahívás után újra felkeresi a mikrofeladatsort. A visszahívások az I/O-ban, az ellenőrzési és a bezárási sorokban ezután hasonló mintázatban hajtódnak végre az egyes fázisok után felkeresett mikrofeladat-sorral.

A hurok továbbra is végrehajtódik, ha több feldolgozandó visszahívás van. Amikor a kódszkript véget ért, vagy nem maradt visszahívások feldolgozása, az eseményhurok hatékonyan véget ér.

Most, hogy mélyen megértjük az eseményhurkot, nézzük meg annak jellemzőit.

Az eseményhurok jellemzői a Node.js-ben

A főbb jellemzők a következők:

• Az eseményhurok egy végtelen hurok, és folytatja a feladatok végrehajtását, amint megkapja azokat, és alvó módba lép, ha nincsenek feladatok, de a feladat beérkezése után azonnal működni kezd.
• Az eseménysorban lévő feladatok csak akkor hajtódnak végre, ha a verem üres, ami azt jelenti, hogy nincs aktív művelet.
• Visszahívások és ígéretek használhatók az eseményhurokban.
• Mivel az eseményhurok az Abstract adattípusú sor elvét követi, teljesíti az első feladatot, majd továbblép a következőre.

Az eseményhurok, valamint az aszinkron és szinkron végrehajtások logikájának alapos megértése után a különböző fázisok megértése megszilárdíthatja az eseményhurok fogalmait.

Node.js eseményhurok fázisai

Mint fentebb említettük, az eseményhurok félig végtelen. Számos fázisa van, de néhány fázist belső kezelésre használnak. Ezek a fázisok nincsenek hatással a kódszkriptre.

Az eseményhurok követi a Queue funkcionalitását, és a feladatot a first-in és first-out elven hajtja végre. Az ütemezett időzítőket az operációs rendszer kezeli lejáratukig. A lejárt időzítők ezután hozzáadódnak az időzítők visszahívási sorához.

Az eseményhurok egyenként hajtja végre az időzítő sorában lévő feladatokat, amíg már nem marad több feladat, vagy el nem éri a maximálisan engedélyezett feladatok számát. Az alábbi szakaszokban az eseményhurkok fő fázisait ismertetjük.

Időzítők fázisa

A Node.js-ben van egy időzítő API, amely ütemezheti a jövőben végrehajtandó funkciókat. A kijelölt idő letelte után az időzítő visszahívása amint ütemezhető; azonban késés léphet fel az operációs rendszer végétől vagy más visszahívások végrehajtása miatt.

Az időzítő API-nak három fő funkciója van:

• setTimeout
• beállítva Azonnali
• setInterval

A fent említett funkciók szinkronban vannak. Az eseményhurok időzítő fázisának hatóköre a setTimeout és setInterval függvényekre korlátozódik. Míg az ellenőrzés funkció kezeli a setImmediate funkciót.

Vegyünk egy egyszerű példát az elméleti rész megszilárdításához:

Ebben a kódban:

• A program a „Program indítása” utasítás naplózásával indul a terminálon.
• Ezután a delayedFunction 2 ms-os időzítővel meghívásra kerül, a kódszkript nem áll le, és tovább kezeli a késleltetést a háttérben.
• A „Program vége” kijelentés az első utasítás után kerül naplózásra.
• 2 ms késleltetés után a delayedFunction utasítása naplózásra kerül a terminálon.

Kimenet

A kimenet így fog megjelenni:

Látható, hogy a kód nem áll le, hogy a delayedFunction feldolgozza; előre mozog, és a késleltetés után a függvény visszahívása feldolgozásra kerül.

Függőben lévő visszahívások

Az eseményhurok ellenőrzi az eseményeket, például a fájlok olvasását, a hálózati tevékenységeket vagy a bemeneti/kimeneti feladatokat a lekérdezési fázisban. Fontos tudni, hogy a Node.js-ben csak az események egy részét kezelik ebben a lekérdezési fázisban. Az eseményhurok ezt követő iterációjában azonban bizonyos események a függőben lévő fázisra halaszthatók. Ez egy kulcsfontosságú fogalom, amelyet szem előtt kell tartani a Node.js kód optimalizálása és hibaelhárítása során, amely összetett eseményvezérelt műveleteket foglal magában.

Fontos megérteni, hogy a várakozó visszahívások fázisában az eseményhurok hozzáadja az elhalasztott eseményeket a függőben lévő visszahívások sorához, és végrehajtja azokat. Ez a fázis kezel néhány, a rendszer által generált TCP socket hibát is, például bizonyos operációs rendszereken az ECONNREFUSED hibaeseményeket.

Az alábbiakban egy példát említünk a koncepció megszilárdítására:

Ebben a kódban:

• A program elindítása a „Program indítása” utasítás naplózásával történik a terminálon.
• A readFileAsync aszinkron módon van definiálva a „PromiseText.txt” fájl tartalmának olvasásához. Ez egy paraméterezett függvény, amely a fájl beolvasása után visszahívási funkciót hajt végre.
• A readFileAsync függvény meghívása elindítja a fájlolvasási folyamatot.
• A fájlolvasás folyamatában a program nem áll le; ehelyett a következő utasításra lép, és bejelentkezik a „Program vége” terminálba.
• A fájlolvasás aszinkron eseményét a háttérben az eseményhurok dolgozza fel.
• A fájl aszinkron olvasása és a tartalom naplózása után a program naplózza a fájl tartalmát a terminálra. Ezt követően a következő üzenetet naplózza: „A fájl visszahívása végrehajtva”.
• Az eseményhurok a következő fázisban kezeli a függőben lévő visszahívási műveleteket.

Kimenet

A fenti végrehajtás eredménye:

Idle, előkészíti a fázist a Node.js-ben

Az üresjárati fázis a Node.js belső funkcióinak kezelésére szolgál, ezért ez nem szabványos fázis. Nem befolyásolja a kódszkriptet. Az üresjárati fázis olyan, mint az eseményhurok megszakítási periódusa, amely alatt az alacsony prioritású feladatokat kezeli a háttérben. Egy egyszerű példa ennek a fázisnak a megértésére:

Ebben a kódban az „idle-gc” modult használják, amely lehetővé teszi az üresjárati fázis figyelmen kívül hagyását. Ez olyan helyzetek kezelésére szolgál, amikor az eseményhurok foglalt, és a háttérfeladatok nem kerülnek végrehajtásra. Az idle.ignore használata nem tekinthető optimálisnak, mivel teljesítménybeli problémákat okozhat.

Lekérdezési fázis a Node.js-ben

A Node.js lekérdezési fázisa a következőképpen működik:

• Kezeli a lekérdezési sorban lévő eseményeket, és elvégzi a hozzájuk tartozó feladatokat.
• Ez dönti el, hogy mennyi időt kell várni és ellenőrizni az I/O műveleteket a folyamatban.

Amikor az eseményhurok időzítő hiánya miatt a lekérdezési fázisba lép, az alábbi feladatok egyike kerül végrehajtásra:

• A Node.js eseményhurok lekérdezési fázisában a függőben lévő I/O események sorba kerülnek, majd a First In és First Out elvét követő szekvenciális eljárásban hajtják végre, amíg a sor ki nem ürül. A visszahívások végrehajtása során a nextTick és a microtasks sorok is működésben vannak. Ez zökkenőmentességet biztosít, és lehetővé teszi az I/O műveletek hatékonyabb és megbízhatóbb kezelését.
• Ha a sor üres, és a szkriptet nem ütemezte a setImmediate() függvény, akkor az eseményhurok véget ér, és a következő fázisba lép (check). Másrészt, ha a szkript ütemezését a setImmediate() függvény hajtotta végre, az eseményhurok lehetővé teszi a visszahívások hozzáadását a sorhoz, amelyeket az általa végrehajtott.

Ezt a legjobban egy egyszerű kódpélda szemlélteti:

Ebben a kódban:

• Két „Start” és „End” üzenet jelzi a program elindítását és befejezését.
• A setTimeout() függvény beállít egy visszahívási függvényt 2 ms-os késleltetéssel, és naplózza a terminálra az „Async művelet befejezve” üzenetet.
• A setImmediate() függvény naplózza a „setImmediate visszahívás végrehajtva” üzenetet a terminálon, miután a Start üzenet naplózásra került a terminálon.

Kimenet

A kimenet csak egy perces megfigyeléssel jeleníti meg az üzeneteket, hogy az „Async művelet befejeződött” időbe telik, és a „Vége” üzenet után kerül kinyomtatásra:

Node.js ellenőrzési fázis

A lekérdezési fázis végrehajtása után az ellenőrző fázisban lévő visszahívások végrehajtásra kerülnek. Ha egy kódszkriptet a setImmediate() függvény segítségével ütemeztek, és a lekérdezési függvény szabad, akkor az eseményhurok úgy működik, hogy közvetlenül az ellenőrzési fázisba lép, ahelyett, hogy tétlen maradna. A setImmediate() függvény egy egyedi időzítő, amely az eseményhurok különböző fázisaiban működik.

A libuv API a visszahívási végrehajtások megtervezésére szolgál a lekérdezési fázis végrehajtása után. A kódvégrehajtás során az eseményhurok belép a lekérdezési fázisba, amelyben várja a bejövő kapcsolódási kéréseket. Egy másik esetben, ha a visszahívás a setImmediate() függvénnyel van ütemezve, és a lekérdezési fázis minden tevékenység nélkül befejeződött, a várakozás helyett az ellenőrzési fázisba lép. A megértéshez vegye figyelembe az alábbi példát:

Ebben a kódban három üzenet van bejelentkezve a terminálra. A setImmediate() függvény végül visszahívást küld az üzenet naplózásához Azonnali visszahívás ” a terminálhoz.

Kimenet

A fenti kód kimenete a következő sorrendben jelenik meg:

Node.js bezárja a visszahívásokat

A Node.js ezt a bezárási fázist használja visszahívások futtatására az események lezárásához és az eseményhurok iterációjának befejezéséhez. A kapcsolat lezárása után az eseményhurok kezeli a záró eseményeket ebben a fázisban. Az eseményhurok ezen fázisában a „nextTick()” és a mikrofeladatok generálása és feldolgozása a többi fázishoz hasonlóan történik.

A process.exit függvény az eseményhurok bármely pillanatban történő befejezésére szolgál. Az eseményhurok figyelmen kívül hagy minden függőben lévő aszinkron műveletet, és a Node.js folyamat leáll.

Egy egyszerű példa megfontolandó:

Ebben a kódban:

• ' const net = megköveteli('net') ” importálja a TCP szerver kezeléséhez szükséges net modult és a „ const server = net.createServer((socket) => { ” létrehoz egy új TCP-kiszolgálópéldányt.
• ' socket.on('close', () => {… } ” hallgatja a „bezárást” az összes aljzaton. Az aljzatcsatlakozás lezárásakor a „Socket Closed” üzenet naplózásra kerül a terminálon.
• ' socket.on('data', (data) => {} ” ellenőrzi a bejövő adatokat az egyes socketekből, és a „.toString()” függvény segítségével kinyomtatja azokat.
• ' server.on('close', () => {…} ” ellenőrzi magán a szerveren a „bezárás” eseményt, és a szerverkapcsolat lezárásakor naplózza a „Server Closed” üzenetet a terminálra.
• ' server.listen(port, () => {…} ” figyeli a bejövő kapcsolatokat a porton.
• ' setTimeout(() => {…} ” 10 ms-os időzítőt állít be a szerver bezárásához.

Ezzel befejeződik a Node.js eseményhurok különböző fázisairól szóló vita. Mielőtt a következtetést levonnánk, beszéljünk még egy utolsó dolgot: hogyan lehet kilépni a Node.js eseményhurokból.

Kilépés a Node.js eseményhurokból

Az eseményhurok mindaddig végrehajtási fázisban van, amíg az eseményhurok fázisok összes sorában van néhány feladat. Az eseményhurok a kilépési fázis kiadása után véget ér, és a kilépési figyelő visszahívása visszatér, ha nincs több feladat a sorokban.

Az eseményhurok lezárásának kifejezett módja a „.exit” metódus használata. A Node.js aktív folyamatai azonnal leállnak, amint a process.exit függvény meghívásra kerül. Az összes tervezett és függőben lévő esemény el lesz távolítva:

A felhasználók meghallgathatják az .exit funkciót. Megjegyzendő, hogy az „.exit” függvénynek szinkronnak kell lennie, mivel a Node.js program azonnal kilép, amint meghallgatja ezt az eseményt.

Ezzel az eseményhurokról szóló vita véget ért. Egy részletes cikk, amely az eseményhurokkal kapcsolatos összes fogalmat, fázist és példát lefedi.

Következtetés

Az eseményhurok megértése előtt a szinkron és az aszinkron fogalmak áttekintése segíthet megérteni az eseményhurok kódfolyamát. A szinkron végrehajtás lépésről lépésre történő végrehajtást jelent, míg az aszinkron végrehajtás bizonyos lépések leállítását jelenti anélkül, hogy megvárná azok befejezését. Az eseményhurok működését és az összes fázist, valamint megfelelő példákat tárgyalunk a cikkben.