Explain async models: callbacks, promises, async/await, and the event loop.

Question

IT Interview Practice · Accepted Answer

**ఇవి ఒకే thread పై non-blocking పనిని వ్యక్తీకరించడానికి క్రమంగా మెరుగైన మార్గాలు, అన్నీ లోపల ready callbacks ను ఒక్కొక్కటిగా run చేసే event loop ద్వారా నడపబడతాయి.** అవి code *ఎప్పుడు* తిరిగి ప్రారంభమవుతుందో నిర్వహిస్తాయి, multiple threads ను కాదు.

## event loop

ఒక single-threaded loop ready callbacks యొక్క queue ను నిర్వహిస్తుంది. ఒక async operation (timer, I/O) పూర్తయినప్పుడు, దాని callback enqueue చేయబడుతుంది; loop తదుపరిదాన్ని ఎంచుకుని దాన్ని పూర్తయ్యే వరకు run చేస్తుంది, తర్వాత పునరావృతం అవుతుంది. run అవుతున్న callback ను ఏదీ preempt చేయదు, కాబట్టి సుదీర్ఘ CPU పని ప్రతిదాన్ని block చేస్తుంది.

```text
[event loop] → run callback → I/O finishes → enqueue callback → run next → ...
```

## మూడు శైలులు

```js
// 1. Callbacks — nesting gets ugly ("callback hell")
readFile('a', (e, a) => readFile('b', (e, b) => done(a, b)));

// 2. Promises — chainable, flat error handling
readFile('a').then(a => readFile('b')).then(b => ...).catch(err => ...);

// 3. async/await — sequential-looking, still non-blocking
async function run() {
  const a = await readFile('a');   // yields to the loop while waiting
  const b = await readFile('b');
  return done(a, b);
}
```

`await` function ను suspend చేసి control ను event loop కు తిరిగి ఇస్తుంది; promise resolve అయినప్పుడు, execution ఆగిన చోట తిరిగి ప్రారంభమవుతుంది. ఇది promises పై syntactic sugar — లోపల అదే event loop.

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

ఈ model Node.js, browsers, మరియు Python asyncio ను నడిపిస్తుంది: lock సంక్లిష్టత లేకుండా ఒక thread పై భారీ I/O concurrency. చిక్కు ఏమిటంటే మీరు loop ను ఎప్పుడూ block చేయకూడదు — ఒక synchronous CPU-heavy లేదా blocking call ప్రతి pending task ను నిలిపివేస్తుంది. async ≠ parallel అని అర్థం చేసుకోవడం ఒక సాధారణ interview discriminator.

event loop

మూడు శైలులు

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

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