Node.js में event loop क्या है और यह कैसे काम करता है?

Question

Accepted Answer

**Event loop** वह तंत्र है जो single-threaded Node.js को **non-blocking I/O** करने की क्षमता देता है। यह निरंतर callbacks की एक queue को process करता है: जबकि आपका JavaScript एक thread पर चलता है, I/O operations को offload किया जाता है, और जब वे complete हो जाते हैं तो loop उनके callbacks को run करता है।

## Loop के phases

हर iteration ("tick") क्रमबद्ध phases से गुजरता है, प्रत्येक के अपने callback queue होते हैं:

```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 phases के बीच चलते हैं (उच्च प्राथमिकता)

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

हर phase के बाद (और sync code के बाद), Node **microtasks** को drain करता है: पहले `process.nextTick` callbacks, फिर Promise callbacks — *इससे पहले* आगे बढ़ना। यही कारण है कि एक resolved Promise `setTimeout(…, 0)` से पहले चलता है।

## यह threads के बिना concurrency को कैसे enable करता है

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

## मुख्य नियम: loop को block न करें

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

Single thread को block करने से सभी request handling रुक जाता है। CPU-heavy work को worker threads को offload करें।

## महत्व क्यों है

Event loop Node के performance model का दिल है — इसके phases और microtask priority को समझना async ordering को explain करता है, क्यों Node एक thread पर huge concurrency को handle करता है, और critical rule जो कभी इसे block न करे।

यह सही, performant Node code लिखने के लिए और surprising async execution order को debug करने के लिए foundational है।