Node.js मधील इव्हेंट लूप म्हणजे काय आणि ते कसे कार्य करते?

Question

Accepted Answer

**इव्हेंट लूप** हा एक यंत्रणा आहे जो एकल-थ्रेडेड Node.js ला **नॉन-ब्लॉकिंग I/O** कार्य करू देतो. हा सतत कॉलबॅक्सच्या रांगेवर प्रक्रिया करतो: जेव्हा तुमचा JavaScript एक थ्रेडवर चालू असतो, तेव्हा I/O ऑपरेशन्स हस्तांतरित केले जातात, आणि ते पूर्ण झाल्यावर त्यांचे कॉलबॅक्स लूपद्वारे चलवले जातात.

## लूपचे टप्पे

प्रत्येक पुनरावृत्ती ("टिक") क्रमबद्ध टप्प्यांतून जाते, प्रत्येकाच्याकडे स्वतःची कॉलबॅक रांग असते:

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

## माइक्रोटास्क्स टप्प्यांमध्ये चालतात (उच्च प्राधान्य)

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

प्रत्येक टप्प्यानंतर (आणि sync कोडनंतर), Node **माइक्रोटास्क्स** ड्रेन करतो: `process.nextTick` कॉलबॅक्स प्रथम, नंतर Promise कॉलबॅक्स — *आधी* पुढे जाण्यापूर्वी. हे कारण आहे की एक resolve केलेले Promise `setTimeout(…, 0)` पूर्वी चालतो.

## हे थ्रेडशिवाय समवर्तीता कसे सक्षम करते

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

## मुख्य नियम: लूप ब्लॉक करू नका

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

एकल थ्रेड ब्लॉक करणे सर्व विनंती हाताळणी थांबवते. CPU-भारी कार्य वर्कर थ्रेड्सकडे स्थानांतरित करा.

## हे महत्वाचे का आहे

इव्हेंट लूप हे Node च्या कार्यक्षमता मॉडेलचे हृदय आहे — त्याच्या टप्प्यांची आणि माइक्रोटास्क प्राधान्यची समजूती async क्रमवारी, Node एकच थ्रेडवर विशाल समवर्तीता कसे हाताळते हे स्पष्ट करते, आणि त्याला कधीही ब्लॉक न करण्याचा महत्वपूर्ण नियम.

ही योग्य, कार्यक्षम Node कोड लिहिण्यासाठी आणि आश्चर्यकारक async execution क्रमाचे निराकरण करण्यासाठी अपरिहार्य आहे.