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 ਉੱਤੇ ਵੱਡੀ I/O concurrency ਬਿਨਾਂ ਕਿਸੇ lock complexity ਦੇ। ਪੇਚ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਦੇ ਵੀ loop ਨੂੰ block ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ — ਇੱਕ synchronous CPU-heavy ਜਾਂ blocking call ਹਰ pending task ਨੂੰ ਰੋਕ ਦਿੰਦਾ ਹੈ। ਇਹ ਸਮਝਣਾ ਕਿ async ≠ parallel ਇੱਕ ਆਮ interview discriminator ਹੈ।

Event loop

ਤਿੰਨ styles

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ