Mikä on event loop Node.js:issa ja kuinka se toimii?

Question

IT Interview Practice · Accepted Answer

**Event loop** on mekanismi, joka mahdollistaa yksisäikeisenNode.js:n suorittaa **non-blocking I/O** -operaatioita. Se käsittelee jatkuvasti callback-jonoa: kun JavaScript-koodisi toimii yhdessä säikeessä, I/O-operaatiot siirretään pois, ja niiden callback-funktiot suoritetaan silmukan kautta kun ne valmistuvat.

## Silmukan vaiheet

Jokaisessa iteraatiossa ("tick") edetään järjestettyjen vaiheiden läpi, joista jokaisella on oma callback-jono:

```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 suoritetaan vaiheiden välillä (korkea prioriteetti)

```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)
```

Jokaisen vaiheen jälkeen (ja synkronisen koodin jälkeen) Node tyhjentää **microtasks**-jonon: ensin `process.nextTick` -callback-funktiot, sitten Promise-callback-funktiot — *ennen* jatkamista. Tämä on syy siihen, miksi ratkaisttu Promise suoritetaan ennen `setTimeout(…, 0)` -komentoa.

## Miksi se mahdollistaa samanaikaisuuden ilman säikeitä

```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.
```

## Kardinaalinen sääntö: älä estä silmukkaa

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

Yksisäikeen estäminen pysäyttää kaiken pyyntöjen käsittelyn. Siirrä CPU-raskas työ worker threadsseihin.

## Miksi sillä on merkitystä

Event loop on Node.js:n suorituskykymallintyypin sydän — sen vaiheiden ja microtask-prioriteetin ymmärtäminen selittää asynkronisen järjestyksen, miksi Node käsittelee valtavaa samanaikaisuutta yhdessä säikeessä, ja kriittisen säännön, joka estää sitä estämästä sitä.

Se on perustavanlaatuinen oikean ja tehokkaan Node-koodin kirjoittamiselle ja yllättävän asynkronisen suoritusjärjestyksen virheenetsinnälle.

Silmukan vaiheet

Microtasks suoritetaan vaiheiden välillä (korkea prioriteetti)

Miksi se mahdollistaa samanaikaisuuden ilman säikeitä

Kardinaalinen sääntö: älä estä silmukkaa

Miksi sillä on merkitystä

Aiheeseen liittyvät kysymykset