Node.js లో event loop అంటే ఏమిటి మరియు ఇది ఎలా పనిచేస్తుంది?

Question

IT Interview Practice · Accepted Answer

**event loop** అనేది single-threaded Node.js లో **non-blocking I/O** పనిచేయడానికి అనుమతించే యంత్రాంగం. ఇది నిరంతరం callbacks యొక్క queue ను process చేస్తుంది: మీ JavaScript ఒక thread పై నడుస్తున్నప్పుడు, I/O operations offload చేయబడతాయి మరియు అవి పూర్ణమైనప్పుడు వాటి callbacks loop ద్వారా నడుపబడతాయి.

## loop యొక్క phases

ప్రతి iteration ("tick") ordered phases ద్వారా కదులుతుంది, ప్రతి phase దానితో సంబంధించిన 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 మధ్య నడుస్తాయి (high priority)

```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 ను ఎలా ప్రారంభిస్తుంది

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

## Cardinal rule: loop ను block చేయవద్దు

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

Single thread ను block చేయడం అన్ని request handling ను halt చేస్తుంది. CPU-heavy work ను worker threads కు offload చేయండి.

## ఇది ఎందుకు ముఖ్యమైనది

Event loop అనేది Node యొక్క performance model యొక్క హృదయం — దాని phases మరియు microtask priority ను అర్థం చేసుకోవడం async ordering, Node ఒక thread పై విशాల concurrency ను ఎలా నిర్వహిస్తుంది మరియు దానిని block చేయకూడదనే critical rule ను వివరిస్తుంది.

ఇది సరైన, performant Node code రాయడానికి మరియు ఆశ్చర్యకరమైన async execution order ను debug చేయడానికి foundational ఆధారపడుతుంది.

loop యొక్క phases

Microtasks phases మధ్య నడుస్తాయి (high priority)

ఇది threads లేకుండా concurrency ను ఎలా ప్రారంభిస్తుంది

Cardinal rule: loop ను block చేయవద్దు

ఇది ఎందుకు ముఖ్యమైనది

సంబంధిత ప్రశ్నలు