Apa kuwi event loop ing Node.js lan paano mekanismane?

Question

Accepted Answer

**Event loop** yaiku mekanisme sing memungkinake Node.js single-threaded kanggo nindakake **non-blocking I/O**. Terus-terusan ngolah antrian callback: nalika JavaScript mu ilalakua ing siji thread, operasi I/O dikasilake, lan callback-e dilakua dening loop nalika rampung.

## Fase-fase loop

Saben iterasi ("tick") pindhah lumaui fase-fase sing urut, saben-sabene duwe antrian callback dhewe:

```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         │
   └───────────────────────────┘
```

## Microtask ilalakua antarane fase (prioritas dhuwur)

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

Sawise saben fase (lan sawise kode sync), Node ngalangi **microtask**: callback `process.nextTick` dhisik, banjur callback Promise — *sadurunge* nerusake. Iki sakteruse yen Promise sing wis rampung ilalakua sadurunge `setTimeout(…, 0)`.

## Kenapa mekanismane ngbukak concurrency tanpa thread

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

## Aturan utama: aja blokir loop

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

Blokir thread tunggal mungkasi kabeh pananganan panjaluk. Pindahake pakaryan CPU-heavy marang worker thread.

## Kenapa iki penting

Event loop yaiku jantung model performa Node — mangerti fase-fasenya lan prioritas microtask nerangke urutan async, kenapa Node nangani concurrency besar ing siji thread, lan aturan kritis kanggo ora blokir.

Dhe dhasar kanggo nulis kode Node sing bener lan performan lan kanggo debug urutan eksekusi async sing ngejutake.