Node.js ਵਿੱਚ event loop ਕੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**event loop** ਇੱਕ ਵਿਧੀ ਹੈ ਜੋ ਸਿੰਗਲ-ਥ੍ਰੈਡ ਵਾਲੇ 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) {}
```

ਸਿੰਗਲ ਥ੍ਰੈਡ ਨੂੰ ਬਲਾਕ ਕਰਨਾ ਸਾਰੀ request ਹਾਂਡਲਿੰਗ ਨੂੰ ਰੋਕ ਦਿੰਦਾ ਹੈ। CPU-ਭਾਰੀ ਕੰਮ ਨੂੰ worker threads ਵਿੱਚ ਭੇਜੋ।

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

event loop Node ਦੇ performance ਮਾਡਲ ਦਾ ਦਿਲ ਹੈ — ਇਸਦੇ ਪੜਾਵਾਂ ਅਤੇ microtask ਦੀ ਤਰਜੀਹ ਦੀ ਸਮਝ async ਕ੍ਰਮ, Node ਇੱਕ ਥ੍ਰੈਡ ਉੱਤੇ ਬਿਸ਼ਾਲ concurrency ਨੂੰ ਕਿਵੇਂ ਹਾਂਡਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਕਦੇ ਬਲਾਕ ਨਾ ਕਰਨ ਦੀ ਮਹੱਤਵਪੂਰਨ ਬਿਨਤੀ ਨੂੰ ਸਮਝਾਉਂਦੀ ਹੈ।

ਇਹ ਸਹੀ, ਕਾਰਗਰ Node ਕੋਡ ਲਿਖਣ ਅਤੇ ਹੈਰਾਨੀ async ਐਕਸੀਕਿউਸ਼ਨ ਕ੍ਰਮ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।