Cad is event loop in Node.js agus conas a oibríonn sé?

Question

Accepted Answer

Is é **event loop** an meicníc a ligeann do Node.js aonshruthach **non-blocking I/O** a dhéanamh. Bíonn sé ag próiseáil scuaine callbacks ar bhealach leanúnach: agus do JavaScript ag rith ar shnáithe amháin, bítear ag scaoileadh amach oibríochtaí I/O, agus bíonn a gcallbacks á rith ag an lúb nuair a bhíonn siad críochnaithe.

## Céimeanna an lúb

Gach ainsréis ("tick") ag dul tríd na céimeanna ordaithe, agus a bhfuil a scuaine callbacks féin ag gach ceann:

```text
   ┌───────────────────────────┐
┌─>│   timers (setTimeout)     │  ← expired timer callbacks
│  ├───────────────────────────┤
│  │   pending I/O callbacks   │
│  ├───────────────────────────┤
│  │   poll (I/O events)       │  ← retrieve new I/O; execute their callbacks
│  ├───────────────────────────┤
│  │   check (setImmediate)    │
│  ├───────────────────────────┤
└──│   close callbacks         │
   └───────────────────────────┘
```

## Microtasks ag rith idir céimeanna (príobháideacht ard)

```js
console.log("1");                          // sync
setTimeout(() => console.log("2"), 0);     // timers phase (macrotask)
setImmediate(() => console.log("3"));      // check phase
Promise.resolve().then(() => console.log("4")); // microtask
process.nextTick(() => console.log("5"));  // nextTick — highest priority
console.log("6");
// Output: 1, 6, 5, 4, 2/3 (timer vs immediate order can vary)
```

I ndiaidh gach céim (agus i ndiaidh an chóid dhocht), scaoileann Node **microtasks** amach: callbacks `process.nextTick` ar dtús, ansin callbacks Promise — *sula bhrúnn sé ar aghaidh*. Seo an fáth go dtéann Promise a réithaítear roimh `setTimeout(…, 0)`.

## Cén fáth a chumasaíonn sé comhthráthúlacht gan snáitheanna

```text
A DB query or file read is handed to the OS/thread pool → Node keeps running
other code → when the result is ready, its callback is queued → the loop runs it.
One thread, thousands of in-flight operations.
```

## An riail chéad-dhéanta: ná stop an lúb

```js
// ❌ a long synchronous loop freezes EVERYTHING — no other callback can run
while (Date.now() - start < 5000) {}
```

Tuisce a stopann an snáithe singil, stopann an phróiseáil go léir iarratais. Scaoil an obair dhrom-chluichí ar oibrithe worker.

## Cén fáth ar cheart duit a bheith i dtuiscint air

Is é an event loop croílár an mhúnla feidhmíochta Node.js — a thuiscint ar a chéimeanna agus ar thosaighde microtask a mhíníonn ord asincronach, cén fáth ar dhéanann Node comhthráthúlacht ollmhór ar shnáithe amháin, agus an riail dhrithrím nach ann a stopadh go deo.

Tá sé bunúsach do chód Node ceart, éifeachtach a scríobh agus do dhochúmhachta aiseolas asincronach iomlán a dhéanamh.