loop ng kaganapan sa node js

Bagama't ang Javascript ay isang single-threaded na wika, ang Node.js ay maaaring magtalaga ng mga gawain sa operating system, na nagbibigay-daan dito na magproseso ng maraming gawain nang sabay-sabay. Maraming mga gawain ang kailangang tapusin nang sabay-sabay dahil ang mga operasyon sa operating system ay multi-threaded. Ang callback na nauugnay sa bawat operasyon ay idinaragdag sa queue ng kaganapan at naka-iskedyul ng Node.js na tumakbo kapag natapos ang tinukoy na gawain.

Upang makapagsulat ng mahusay at maaasahang Node.js code, dapat na may matatag na pag-unawa ang user sa mga loop ng kaganapan. Makakatulong din ito sa epektibong pag-troubleshoot ng mga isyu sa performance. Ang event loop sa Node.js ay nakakatipid ng memory at nagbibigay-daan sa iyong gumawa ng maraming bagay nang sabay-sabay nang hindi kinakailangang maghintay para matapos ang bawat isa. Ang terminong 'asynchronous' ay tumutukoy sa anumang Javascript function na tumatakbo sa background nang hindi hinaharangan ang mga papasok na kahilingan.

Bago tumalon nang direkta sa mga loop ng kaganapan, tingnan natin ang iba't ibang aspeto ng Javascript programming language.

Ang Javascript bilang isang asynchronous na programming language

Tingnan natin ang mga konsepto ng asynchronous programming. Ginagamit ang Javascript sa web, mobile, at desktop application, ngunit dapat tandaan na ang Javascript ay isang single-threaded, synchronous na computer programming language.

Ang isang simpleng halimbawa ng code ay ibinigay upang maunawaan ang konsepto.

Sa code na ito, dalawang simpleng function ang nilikha at ang method1 ay unang tinatawag upang ito ay mag-log method1 muna at pagkatapos ay lumipat sa susunod.

Output

Javascript bilang isang synchronous programming language

Ang Javascript ay isang synchronous na programming language at isinasagawa ang bawat linya nang hakbang-hakbang na gumagalaw mula sa itaas hanggang sa ibaba na may isang linya lamang na isinasagawa sa isang pagkakataon. Sa halimbawang code na ibinigay sa itaas ang method1 ay unang naka-log sa terminal at pagkatapos ay ang method2.

Javascript bilang isang Blocking Language

Ang pagiging isang kasabay na javascript ng wika ay may pag-andar ng pagharang. Hindi mahalaga kung gaano katagal bago makumpleto ang isang patuloy na proseso ngunit ang isang bagong proseso ay hindi magsisimula hanggang sa nakumpleto ang nauna. Sa halimbawa ng code sa itaas, ipagpalagay na mayroong maraming code script sa method1 kahit gaano pa katagal ang aabutin ng alinman sa 10 segundo o isang minutong method2 ay hindi isasagawa hanggang ang lahat ng code sa method1 ay naisakatuparan.

Maaaring naranasan ito ng mga user habang nagba-browse. Kapag ang isang web application ay nag-execute sa isang browser sa back-end, isang malaking tipak ng code ang ginagawa kaya ang browser ay mukhang na-freeze nang ilang oras bago ibalik ang control access sa user. Ang pag-uugaling ito ay kilala bilang pagharang. Ang browser ay hindi maaaring magbigay ng anumang karagdagang mga papasok na kahilingan hanggang sa ang kasalukuyang kahilingan ay naproseso.

Ang Javascript ay isang single-threaded na Wika

Upang magpatakbo ng isang programa sa javascript ang thread functionality ay ginagamit. Ang mga thread ay may kakayahang magsagawa lamang ng isang gawain sa isang pagkakataon. Sinusuportahan ng iba pang mga programming language ang multi-threading at maaaring magpatakbo ng maraming gawain nang magkatulad, ang javascript ay naglalaman lamang ng isang thread para sa pagpapatupad ng anumang code script.

Naghihintay sa Javascript

Tulad ng nakikita mula sa pangalan sa seksyong ito, kailangan naming maghintay para sa aming kahilingan na maproseso upang magpatuloy pa. Ang paghihintay ay maaaring tumagal ng ilang minuto kung saan walang karagdagang kahilingan ang naaaliw. Kung magpapatuloy ang code script nang hindi naghihintay, magkakaroon ng error ang code. Ang ilang functionality ay ipapatupad sa Javascript o mas partikular na Node.js para gawing asynchronous ang code.

Ngayong naunawaan na natin ang iba't ibang aspeto ng Javascript, unawain natin ang kasabay at asynchronous sa pamamagitan ng ilang simpleng halimbawa.

Kasabay na pagpapatupad ng code sa Javascript

Ang kasabay ay nangangahulugan na ang code ay isinasagawa nang sunud-sunod o mas simpleng hakbang-hakbang na nagsisimula mula sa itaas at gumagalaw pababa linya sa linya.

Sa ibaba ay ibinigay ang isang halimbawa na makakatulong na maunawaan:

Sa code na ito, mayroong tatlong console.log statement bawat isa ay nagpi-print ng isang bagay. Una ang unang pahayag na magpi-print ng 'Isa' sa console ay ipinadala sa call stack para sa 1 ms (tinantyang) pagkatapos ito ay naka-log sa terminal. Pagkatapos nito, ang pangalawang pahayag ay itinulak sa stack ng tawag at ngayon ang oras ay 2 ms na may idinagdag mula sa nauna at pagkatapos ay i-log ang 'Dalawang' sa console. Sa wakas, ang huling pahayag ay itinulak sa call stack sa ngayon ang oras ay 3ms at ito ay nag-log ng 'Tatlo' sa console.

Ang code sa itaas ay maaaring isagawa sa pamamagitan ng paggamit ng sumusunod na command:

Output

Ang paggana ay ipinaliwanag sa itaas nang detalyado at sa pamamagitan ng pag-iingat nito sa pagsasaalang-alang ang output ay naka-log in sa console sa isang kisap-mata:

Asynchronous na pagpapatupad ng code sa Javascript

Ngayon, hayaan nating i-refactor ang parehong code sa pamamagitan ng pagpapakilala ng mga callback at gawing asynchronous ang code. Ang code sa itaas ay maaaring refactored bilang:

Sa code na ito sa itaas:

• Tatlong function ang idineklara upang i-print ang 'Isa', 'Dalawa' at 'Tatlo', ang bawat function ay may parameter ng callback na nagbibigay-daan sa sunud-sunod na pagpapatupad ng code.
• Ang isang timeout ay nakatakda gamit ang setTimeout function at mayroong console.log statement para sa pag-print pagkatapos ng isang partikular na pagkaantala.
• Dalawang mensahe ang nakalimbag na 'Simulan ng Programa' at 'Pagtatapos ng Programa' na nagpapahiwatig ng simula at pagtatapos ng programa.
• Ang programa ay nagsisimula sa pamamagitan ng pag-print ng 'Start of the Program' pagkatapos kung saan ang printOne function ay ipapatupad na may 1 segundong pagkaantala, pagkatapos ang printTwo function ay isasagawa na may 2-segundong pagkaantala, at sa wakas ang printThree function ay isinasagawa na may 3 segundo. pagkaantala.
• Ang programa ay hindi naghihintay para sa asynchronous code executions sa loob ng setTimeouts function na nagla-log sa 'End of the Program' statement bago mag-print ng Isa, Dalawa, at Tatlo.

Output

Patakbuhin ang code sa itaas sa pamamagitan ng pagsasagawa ng command na ito sa terminal:

Ngayon ang output sa terminal ay lalabas nang asynchronously bilang:

Ngayong mayroon na tayong kumpletong pag-unawa sa kasabay at asynchronous na pagpapatupad, tumalon tayo upang patatagin ang ating konsepto ng event loop sa Node.js.

Node.js: Event Loop Mechanism

Ang pagsasagawa ng parehong kasabay at asynchronous na mga gawain ay pinamamahalaan ng loop ng kaganapan sa Node.js. Ang pagpapatupad ay ipapatupad sa sandaling ang proyekto ng Node.js ay inilunsad at maayos na inilipat ang mga kumplikadong gawain sa system. Tinitiyak nito na ang iba pang mga gawain ay maaaring tumakbo nang maayos sa pangunahing thread.

Visual na Paliwanag ng Event Loop sa Node.js

Ang event loop ay tuloy-tuloy at semi-infinite sa Node.js. Ang event loop ay na-invoke sa pamamagitan ng pagsisimula ng Node.js code script, at ito ay responsable para sa paggawa ng async API na mga tawag at mga proseso ng pagtawag. Tick(), at pag-iskedyul ng mga timer pagkatapos ay ipagpatuloy ang pagpapatupad ng event loop.

Sa Node.js, limang pangunahing uri ng mga pila ang humahawak ng mga callback:

• Ang 'Timer Queue' na karaniwang kilala bilang isang min-heap ay responsable para sa paghawak ng mga callback na nauugnay sa 'setTimeout' at 'setInterval.'
• Ang mga callback para sa mga asynchronous na operasyon tulad ng sa 'fs' at 'http' na mga module ay pinangangasiwaan ng 'I/O Queue'.
• Ang 'Check Queue' ay naglalaman ng mga callback para sa 'setImmediate' function na natatangi sa Node.
• Ang 'Isara ang Queue' ay namamahala sa mga callback na nauugnay sa anumang kaganapan ng pagsasara ng asynchronous na gawain.
• Panghuli, mayroong dalawang magkaibang pila sa queue ng 'Micro Task':
  • Ang queue na 'nextTick' ay naglalaman ng mga callback na nauugnay sa function na 'process.nextTick'.
  • Kinokontrol ng queue na 'Pangako' ang mga callback na nauugnay sa native na Pangako.

Pag-andar ng Event Loop sa Node.js

Gumagana ang event loop sa ilalim ng mga partikular na kinakailangan na kumokontrol sa pagkakasunud-sunod ng pagpapatupad ng callback. Binibigyan ng priyoridad ang kasabay na Javascript code ng user sa simula ng proseso, kaya magsisimula lang ang event loop kapag na-clear ang call stack. Ang sumusunod na execution sequence ay sumusunod sa structured pattern:

Ang pinakamataas na priyoridad ay ibinibigay sa mga callback sa microtask queue pagkatapos ay gumagalaw upang isagawa ang mga gawain sa nextTick queue na sinusundan ng mga gawain sa Promise queue. Ang mga proseso sa mga callback ng queue ng timer ay pinangangasiwaan pagkatapos nito ang microtask queue ay muling binibisita pagkatapos ng bawat callback ng timer. Ang mga callback sa I/O, check at close queue ay ipapatupad sa isang katulad na pattern sa microtask queue na binisita pagkatapos ng bawat phase.

Ang loop ay patuloy na ipapatupad kung mayroong higit pang mga callback na ipoproseso. Kapag natapos na ang code script o walang natitira pang mga callback upang maproseso, matatapos ang event loop nang mahusay.

Ngayon na malalim na nating naiintindihan ang Event loop, tingnan natin ang mga feature nito.

Mga tampok ng event loop sa Node.js

Ang mga pangunahing tampok ay:

• Ang event loop ay isang infinite loop at patuloy na isinasagawa ang mga gawain sa sandaling matanggap nito ang mga ito at mapupunta sa sleep mode kung sakaling walang mga gawain ngunit magsisimulang gumana sa sandaling matanggap ang gawain.
• Ang mga gawain sa queue ng kaganapan ay isinasagawa lamang kapag ang stack ay walang laman ay nangangahulugan na walang aktibong operasyon.
• Maaaring gamitin ang mga callback at pangako sa loop ng kaganapan.
• Habang sinusunod ng event loop ang prinsipyo ng Abstract na uri ng data queue natutupad nito ang unang gawain pagkatapos ay nagpapatuloy sa susunod.

Pagkatapos ng masusing pag-unawa sa event loop, at sa logic ng asynchronous at synchronous executions, ang pagkuha ng pag-unawa sa iba't ibang phase ay maaaring patatagin ang mga konsepto ng event loop.

Node.js Event loop Phase

Gaya ng nabanggit sa itaas, semi-infinite ang event loop. Mayroon itong maraming mga yugto ngunit ang ilang mga yugto ay ginagamit para sa panloob na paghawak. Ang mga phase na ito ay walang anumang epekto sa code script.

Ang event loop ay sumusunod sa functionality ng Queue at isinasagawa ang gawain sa prinsipyo ng first-in at first-out. Ang mga naka-iskedyul na timer ay hahawakan ng operating system hanggang sa mag-expire ang mga ito. Ang mga nag-expire na timer ay idaragdag sa queue ng callback para sa mga timer.

Isinasagawa ng event loop ang mga gawain sa pila ng timer nang paisa-isa hanggang sa wala nang natitirang gawain o maabot nito ang maximum na pinapayagang bilang ng mga gawain. Sa mga seksyon sa ibaba ang mga pangunahing yugto ng mga loop ng kaganapan ay ipinaliwanag.

Phase ng mga Timer

Sa Node.js mayroong timer API na maaaring mag-iskedyul ng mga function na isasagawa sa hinaharap. Matapos lumipas ang inilaang oras, isasagawa ang callback ng timer sa sandaling maiiskedyul ang mga ito; gayunpaman, maaaring magkaroon ng pagkaantala mula sa dulo ng operating system o dahil sa pagpapatupad ng iba pang mga callback.

Ang timers API ay may tatlong pangunahing function:

• setTimeout
• itakdaAgad
• setInterval

Ang mga nabanggit na function ay magkasabay. Ang yugto ng timer sa loop ng kaganapan ay limitado ang saklaw nito sa mga function ng setTimeout at setInterval. Habang pinangangasiwaan ng check function ang setImmediate function.

Isaalang-alang natin ang isang simpleng halimbawa upang patatagin ang teoretikal na bahagi:

Sa code na ito:

• Magsisimula ang programa sa pamamagitan ng pag-log sa pahayag na 'Start of the Program' sa terminal.
• Pagkatapos ang delayedFunction ay tinatawag na may timer na 2ms, ang code script ay hindi huminto at nagpapatuloy sa karagdagang paghawak sa pagkaantala sa background.
• Ang pahayag na 'Pagtatapos ng Programa ay naka-log pagkatapos ng unang pahayag.
• Pagkatapos ng pagkaantala ng 2ms, ang pahayag sa delayedFunction ay naka-log sa terminal.

Output

Ang output ay lalabas bilang:

Ito ay makikita na ang code ay hindi tumigil para sa delayedFunction upang iproseso; umuusad ito at pagkatapos ng pagkaantala, pinoproseso ang function callback.

Mga Nakabinbing Callback

Sinusuri ng loop ng kaganapan ang mga kaganapang nangyayari, tulad ng pagbabasa ng mga file, aktibidad sa network, o mga gawain sa pag-input/output, sa yugto ng botohan. Mahalagang malaman na, sa Node.js, ilan lang sa mga kaganapan ang pinangangasiwaan sa yugto ng botohan na ito. Gayunpaman, sa kasunod na pag-ulit ng loop ng kaganapan, maaaring ipagpaliban ang ilang partikular na kaganapan sa nakabinbing yugto. Ito ay isang mahalagang konsepto na dapat tandaan kapag nag-o-optimize at nag-troubleshoot ng Node.js code na nagsasangkot ng mga kumplikadong operasyong hinihimok ng kaganapan.

Mahalagang maunawaan na sa yugto ng paghihintay ng mga callback, ang loop ng kaganapan ay nagdaragdag ng mga ipinagpaliban na kaganapan sa pila ng mga nakabinbing callback at isinasagawa ang mga ito. Ang yugtong ito ay pinangangasiwaan din ang ilang TCP socket error na nabuo ng system, gaya ng ECONNREFUSED error event sa ilang partikular na operating system.

Sa ibaba ay binanggit ang isang halimbawa upang patatagin ang konsepto:

Sa code na ito:

• Ang programa ay pinasimulan sa pamamagitan ng pag-log sa pahayag na 'Start of the Program' sa terminal.
• Ang readFileAsync ay tinukoy nang asynchronous upang basahin ang nilalaman ng file na 'PromiseText.txt'. Ito ay isang parametrized function na nagsasagawa ng callback function pagkatapos basahin ang file.
• Ang readFileAsync function ay tinatawag upang simulan ang proseso ng pagbabasa ng file.
• Sa proseso ng pagbabasa ng file, hindi humihinto ang programa; sa halip, magpapatuloy ito sa susunod na pahayag at i-log ito sa terminal na 'Pagtatapos ng Programa'.
• Ang asynchronous na kaganapan ng pagbabasa ng file ay pinoproseso sa background ng event loop.
• Matapos ang file ay nabasa nang asynchronously at ang nilalaman ay nai-log sa terminal ang programa ay nag-log ng nilalaman ng file sa terminal. Pagkatapos nito, ini-log nito ang sumusunod na mensahe na 'Naisakatuparan ang file read callback'.
• Pinangangasiwaan ng event loop ang mga nakabinbing pagpapatakbo ng callback sa susunod na yugto.

Output

Ang resulta ng pagpapatupad sa itaas ay:

Idle, Maghanda ng Phase sa Node.js

Ang idle phase ay ginagamit upang harapin ang mga panloob na function sa Node.js kaya hindi ito isang karaniwang yugto. Hindi ito nakakaimpluwensya sa code script. Ang idle phase ay parang break period para sa event loop kung saan pinapamahalaan ang mga gawaing mababa ang priyoridad sa background. Ang isang simpleng halimbawa upang maunawaan ang yugtong ito ay:

Sa code na ito, ginagamit ang module na 'idle-gc' na nagbibigay-daan sa hindi pagpansin sa idle phase. Nagsisilbi itong pangasiwaan ang mga sitwasyon kapag abala ang loop ng kaganapan at hindi ginagawa ang mga gawain sa background. Ang paggamit ng idle.ignore ay hindi itinuturing na pinakamainam dahil maaari itong magdulot ng mga isyu sa pagganap.

Yugto ng botohan sa Node.js

Ang yugto ng poll sa Node.js ay nagsisilbing:

• Pinangangasiwaan nito ang mga kaganapan sa pila ng poll at ginagawa ang kanilang mga kaukulang gawain.
• Nagpapasya ito kung gaano karaming oras ang gugugol sa paghihintay at pagsuri para sa mga operasyon ng I/O sa proseso.

Habang papasok ang event loop sa yugto ng poll dahil sa kawalan ng timer isa sa mga gawain sa ibaba ang isasagawa:

• Sa yugto ng poll ng event loop sa Node.js, ang mga nakabinbing I/O na kaganapan ay naka-queue at pagkatapos ay isasagawa sa sunud-sunod na pamamaraan na sumusunod sa prinsipyo ng First In at First Out hanggang sa maging walang laman ang queue. Sa panahon ng mga callback execution ang nextTick at microtasks queues ay kumikilos din. Tinitiyak nito ang kinis at nagbibigay-daan upang pangasiwaan ang mga operasyon ng I/O nang mas mahusay at mapagkakatiwalaan.
• Kung ang queue ay walang laman at ang script ay hindi nakaiskedyul ng setImmediate() function pagkatapos ay ang event loop ay magtatapos at ito ay magpapatuloy sa susunod na yugto(check). Sa kabilang banda, kung ang pag-iskedyul ng script ay ginawa ng setImmediate() function, pinapayagan ng event loop ang mga callback na maidagdag sa pila na isasagawa nito.

Ito ay pinakamahusay na inilarawan sa isang simpleng halimbawa ng code:

Sa code na ito:

• Dalawang mensaheng 'Start' at 'End' ang nagpapahiwatig ng pagsisimula at pagwawakas ng programa.
• Ang setTimeout() function ay nagtatakda ng callback function na may pagkaantala ng 2 ms at nag-log 'Async operation completed' sa terminal.
• Ang setImmediate() function ay nagla-log ng mensaheng 'setImmediate callback executed' sa terminal pagkatapos na mai-log ang Start message sa terminal.

Output

Ipapakita ng output ang mga mensahe na may isang minutong pagmamasid lang na ang 'Nakumpleto ang operasyon ng Async' ay tumatagal ng oras at naka-print pagkatapos ng 'End' na mensahe:

Yugto ng Pagsusuri ng Node.js

Matapos maisakatuparan ang yugto ng poll, ang mga callback sa yugto ng pagsusuri ay isasagawa. Kung ang isang code script ay naka-iskedyul gamit ang setImmediate() function at ang poll function ay libre, ang event loop ay gagana sa pamamagitan ng direktang paglipat sa check phase sa halip na manatiling idle. Ang setImmediate() function ay isang natatanging timer na gumagana sa iba't ibang yugto ng event loop.

Ang libuv API ay ginagamit upang planuhin ang mga callback execution pagkatapos makumpleto ang poll phase execution. Sa panahon ng pagpapatupad ng code, ang loop ng kaganapan ay pumapasok sa yugto ng poll kung saan naghihintay ito para sa mga papasok na kahilingan sa koneksyon. Sa ibang kaso kung ang callback ay naka-iskedyul gamit ang setImmediate() function at ang poll phase ay winakasan nang walang anumang aktibidad lilipat ito sa check phase sa halip na maghintay. Isaalang-alang ang halimbawa sa ibaba para sa pag-unawa:

Sa code na ito tatlong mensahe ang naka-log on sa terminal. Ang setImmediate() function pagkatapos ay sa wakas ay nagpapadala ng isang callback upang i-log ang mensahe ' Agad na callback ” sa terminal.

Output

Ang output ng code sa itaas ay lalabas sa sumusunod na pagkakasunud-sunod:

Isinara ng Node.js ang mga callback

Ginagamit ng Node.js ang malapit na bahaging ito upang magpatakbo ng mga callback upang isara ang mga kaganapan at tapusin ang isang pag-ulit ng loop ng kaganapan. Pagkatapos maisara ang koneksyon, ang event loop ang humahawak sa mga closing event sa phase na ito. Sa yugtong ito ng loop ng kaganapan, ang 'nextTick()' at mga microtasks ay nabuo at pinoproseso nang katulad ng iba pang mga yugto.

Ang process.exit function ay ginagamit upang tapusin ang event loop sa anumang sandali. Ang event loop ay hindi papansinin ang anumang nakabinbing asynchronous na mga operasyon at ang proseso ng Node.js ay magwawakas.

Ang isang simpleng halimbawa na dapat isaalang-alang ay:

Sa code na ito:

• “ const net = nangangailangan('net') ' ini-import ang net module na kinakailangan upang mahawakan ang isang TCP server at ' const server = net.createServer((socket) => { ” ay lumilikha ng bagong instance ng TCP server.
• “ socket.on(‘close’, () => {… } ' nakikinig sa 'close' sa lahat ng mga socket. Kapag ang koneksyon ng socket ay sarado ang mensaheng 'Socket Closed' ay naka-log sa terminal.
• “ socket.on(‘data’, (data) => {} ” sumusuri para sa papasok na data mula sa lahat ng indibidwal na socket at ipi-print ito gamit ang function na “.toString()”.
• “ server.on(‘close’, () => {…} Sinusuri ng ” ang “close” na kaganapan sa server mismo, at kapag ang koneksyon ng server ay sarado, ini-log nito ang mensaheng “Server Closed” sa terminal.
• “ server.listen(port, () => {…} ” nakikinig sa mga papasok na koneksyon sa port.
• “ setTimeout(() => {…} ” nagtatakda ng timer na 10 ms para isara ang server.

Iyon ay nagtatapos sa talakayan sa iba't ibang yugto ng event loop sa Node.js. Bago tumalon sa isang konklusyon, talakayin natin ang isang huling bagay kung saan ay kung paano lumabas sa loop ng kaganapan sa Node.js.

Paglabas sa Event Loop sa Node.js

Ang loop ng kaganapan ay nasa yugto ng pagpapatupad hangga't mayroong ilang mga gawain sa lahat ng mga pila ng mga yugto ng loop ng kaganapan. Ang loop ng kaganapan ay nagtatapos pagkatapos na lumabas ang yugto ng paglabas at ang exit listener callback ay babalik kung wala nang mga gawain sa mga pila.

Ang tahasang paraan para tapusin ang isang event loop ay ang paggamit ng '.exit' na paraan. Ang mga aktibong proseso ng Node.js ay magwawakas kaagad sa sandaling tawagin ang process.exit function. Ang lahat ng naka-iskedyul at nakabinbing mga kaganapan ay aalisin:

Maaaring makinig ang mga user sa .exit function. Dapat tandaan na ang function na '.exit' ay dapat na magkasabay dahil ang Node.js program ay lalabas sa sandaling ito ay makinig sa kaganapang ito.

Tinatapos nito ang talakayan sa loop ng kaganapan. Isang malalim na artikulo na sumaklaw sa lahat ng mga konsepto, yugto, at mga halimbawang nauugnay sa loop ng kaganapan.

Konklusyon

Bago unawain ang loop ng kaganapan, makakatulong ang isang pangkalahatang-ideya ng mga kasabay at asynchronous na konsepto upang maunawaan ang daloy ng code sa loop ng kaganapan. Ang sabay-sabay na pagpapatupad ay nangangahulugan ng sunud-sunod na pagpapatupad habang ang asynchronous na pagpapatupad ay nangangahulugang paghinto ng ilang hakbang nang hindi naghihintay sa kanilang pagkumpleto. Ang pagtatrabaho ng loop ng kaganapan kasama ang lahat ng mga yugto kasama ang mga angkop na halimbawa ay tinalakay sa artikulo.