Node.js માં event loop શું છે અને તે કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**Event loop** એ એક પદ્ધતિ છે જે single-threaded Node.js ને **non-blocking I/O** કરવા દે છે। તે સતત callbacks ની કતાર પ્રક્રિયા કરે છે: જ્યારે તમારું JavaScript એક થ્રેડ પર ચલાવાય છે, I/O કામગીરી કાઢવામાં આવે છે અને જ્યારે તે પૂર્ણ થાય છે ત્યારે તેમનાcallbacks લૂપ દ્વારા ચલાવવામાં આવે છે।

## લૂપના તબક્કા

પ્રતિ પુનરાવૃત્તિ ("tick") ક્રમમાં તબક્કાઓ પર જાય છે, દરેક તેની પોતાની callback કતાર સાથે:

```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 તબક્કાઓ વચ્ચે ચાલે છે (ઉચ્ચ અગ્રતા)

```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 **microtasks** બહાર કાઢે છે: પ્રથમ `process.nextTick` callbacks, પછી Promise callbacks — *આગળ વધતા પહેલાં*. આ કારણ છે કે resolved Promise `setTimeout(…, 0)` પહેલાં ચલે છે.

## તે થ્રેડ્સ વિના concurrency કેવી રીતે સક્ષમ કરે છે

```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-ભારે કાર્યોને worker threads માં દૂર કરો।

## તે શા માટે મહત્વપૂર્ણ છે

Event loop એ Node.js ના પ્રદર્શન મોડલનું હૃદય છે — તેના તબક્કાઓ અને microtask અગ્રતા સમજવું async ક્રમશને સમજાવે છે, કેમ Node એક થ્રેડ પર વિશાળ concurrency સંભાળે છે, અને તેને કદી અટકાવશો નહીં તેનો મહત્વપૂર્ણ નિયમ।

સાચો અને કાર્યક્ષમ Node કોડ લખવા અને આશ્ચર્યજનક async સમપાત ક્રમમાં ડીબગ કરવા માટે તે મૂળભૂત છે.