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

Question

IT Interview Practice · 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 क्रमाचे निराकरण करण्यासाठी अपरिहार्य आहे.

लूपचे टप्पे

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

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

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

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

संबंधित प्रश्न