async models સમજાવો: callbacks, promises, async/await, અને event loop.

Question

IT Interview Practice · Accepted Answer

**આ એક જ thread પર non-blocking કામ વ્યક્ત કરવાની ક્રમશઃ સારી રીતો છે, જે બધી નીચેથી એક event loop દ્વારા ચલાવાય છે જે ready callbacks ને એક સમયે એક ચલાવે છે.** તે code *ક્યારે* ફરી શરૂ થાય તે સંભાળે છે, અનેક threads નહીં.

## Event loop

એક single-threaded loop ready callbacks ની queue જાળવે છે. જ્યારે async operation (timer, I/O) પૂરું થાય, ત્યારે તેનો callback enqueue થાય છે; loop આગળનો પસંદ કરે છે અને તેને પૂર્ણ સુધી ચલાવે છે, પછી પુનરાવર્તન કરે છે. ચાલતા callback ને કંઈ preempt કરતું નથી, તેથી લાંબું CPU કામ બધું block કરે છે.

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

## ત્રણ styles

```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 ને શક્તિ આપે છે: એક thread પર lock જટિલતા વગર વિશાળ I/O concurrency. પકડ એ છે કે તમારે loop ને ક્યારેય block ન કરવો — એક synchronous CPU-ભારે કે blocking call દરેક pending task ને અટકાવે છે. async ≠ parallel એ સમજવું એ સામાન્ય interview discriminator છે.

Event loop

ત્રણ styles

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો