Node.js ਵਿੱਚ ਬਲਾਕਿੰਗ ਅਤੇ ਨਾਨ-ਬਲਾਕਿੰਗ ਓਪਰੇਸ਼ਨਾਂ ਵਿਚਕਾਰ ਕੀ ਫ਼ਰਕ ਹੈ?

Question

IT Interview Practice · Accepted Answer

**ਬਲਾਕਿੰਗ** (blocking) ਓਪਰੇਸ਼ਨ ਸਿੰਕ੍ਰੋਨਸ ਢੰਗ ਨਾਲ ਚੱਲਦੇ ਹਨ ਅਤੇ ਇੱਕੋ-ਇੱਕ JavaScript ਥਰੈੱਡ ਨੂੰ ਪੂਰਾ ਹੋਣ ਤੱਕ ਰੋਕੀ ਰੱਖਦੇ ਹਨ — ਇਸ ਦੌਰਾਨ ਹੋਰ ਕੁਝ ਵੀ ਨਹੀਂ ਚੱਲ ਸਕਦਾ। **ਨਾਨ-ਬਲਾਕਿੰਗ** (non-blocking) ਓਪਰੇਸ਼ਨ ਕੰਮ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ, ਤੁਰੰਤ ਵਾਪਸ ਮੁੜਦੇ ਹਨ, ਅਤੇ ਨਤੀਜਾ ਬਾਅਦ ਵਿੱਚ ਇੱਕ callback, Promise ਜਾਂ event ਰਾਹੀਂ ਦਿੰਦੇ ਹਨ, ਇਸ ਲਈ ਥਰੈੱਡ ਹੋਰ ਕੰਮ ਕਰਨ ਲਈ ਖਾਲੀ ਰਹਿੰਦਾ ਹੈ।

## Node ਸਿੰਗਲ-ਥਰੈੱਡਡ ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਨਾਨ-ਬਲਾਕਿੰਗ ਕਿਉਂ ਹੈ

ਤੁਹਾਡਾ JavaScript **ਇੱਕ** ਥਰੈੱਡ ਉੱਤੇ ਚੱਲਦਾ ਹੈ ਜਿਸ ਨੂੰ **event loop** ਚਲਾਉਂਦਾ ਹੈ। I/O (ਫ਼ਾਈਲਾਂ, ਨੈੱਟਵਰਕ, DNS) ਨੂੰ **libuv** ਨੂੰ ਸੌਂਪਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਅੰਦਰੋਂ OS ਦੀਆਂ ਅਸਿੰਕ੍ਰੋਨਸ ਸਹੂਲਤਾਂ ਅਤੇ ਇੱਕ ਛੋਟਾ **thread pool** ਵਰਤਦਾ ਹੈ। ਜਦੋਂ ਉਹ ਕੰਮ ਥਰੈੱਡ ਤੋਂ ਬਾਹਰ ਹੁੰਦਾ ਹੈ, event loop ਹੋਰ callback-ਾਂ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ। ਜਦੋਂ I/O ਪੂਰਾ ਹੁੰਦਾ ਹੈ, ਇਸ ਦਾ callback ਕਤਾਰ ਵਿੱਚ ਲੱਗਦਾ ਹੈ ਅਤੇ ਚੱਲਦਾ ਹੈ।

```js
const fs = require("node:fs");

// Blocking: ਪੂਰੀ ਪ੍ਰੋਸੈਸ ਇੱਥੇ ਇੰਤਜ਼ਾਰ ਕਰਦੀ ਹੈ; ਹੋਰ ਕੋਈ ਵੀ ਬੇਨਤੀ ਸਰਵ ਨਹੀਂ ਹੁੰਦੀ।
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: ਤੁਰੰਤ ਵਾਪਸ ਮੁੜਦਾ ਹੈ; callback ਉਦੋਂ ਚੱਲਦਾ ਹੈ ਜਦੋਂ I/O ਪੂਰਾ ਹੁੰਦਾ ਹੈ।
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## ਬਲਾਕਿੰਗ vs ਨਾਨ-ਬਲਾਕਿੰਗ

| | ਬਲਾਕਿੰਗ | ਨਾਨ-ਬਲਾਕਿੰਗ |
|---|---|---|
| API ਸ਼ੈਲੀ | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| ਥਰੈੱਡ | event loop ਨੂੰ ਰੋਕੀ ਰੱਖਦਾ ਹੈ | event loop ਨੂੰ ਖਾਲੀ ਕਰਦਾ ਹੈ |
| ਥਰੂਪੁੱਟ | ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਬੇਨਤੀ | ਇੱਕੋ ਸਮੇਂ ਕਈ ਬੇਨਤੀਆਂ |
| ਕਦੋਂ ਵਰਤੋ | ਸਟਾਰਟਅੱਪ/CLI ਸਕ੍ਰਿਪਟਾਂ | ਸਰਵਰ, ਬੇਨਤੀ ਹੈਂਡਲਰ |

## ਫੰਦਾ: CPU-ਬਾਊਂਡ ਕੰਮ ਫਿਰ ਵੀ ਬਲਾਕ ਕਰਦਾ ਹੈ

ਨਾਨ-ਬਲਾਕਿੰਗ ਸਿਰਫ਼ **I/O** ਨਾਲ ਮਦਦ ਕਰਦਾ ਹੈ। ਇੱਕ ਭਾਰੀ ਸਿੰਕ੍ਰੋਨਸ ਗਣਨਾ (ਵੱਡੇ JSON payload ਨੂੰ ਪਾਰਸ ਕਰਨਾ, ਕ੍ਰਿਪਟੋ, ਚਿੱਤਰ ਦਾ ਆਕਾਰ ਬਦਲਣਾ, ਇੱਕ ਤੰਗ ਲੂਪ) event loop ਨੂੰ `async` ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਵੀ ਬਲਾਕ ਕਰ ਦਿੰਦੀ ਹੈ, ਕਿਉਂਕਿ CPU ਦਾ ਕੰਮ ਖ਼ੁਦ JS ਥਰੈੱਡ ਉੱਤੇ ਚੱਲਦਾ ਹੈ।

```js
// "async" ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਪੂਰੇ ਲੂਪ ਦੌਰਾਨ event loop ਨੂੰ ਬਲਾਕ ਕਰਦਾ ਹੈ।
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-ਬਾਊਂਡ, ਸਿੰਕ੍ਰੋਨਸ
  return x;
}
```

CPU-ਬਾਊਂਡ ਕੰਮ ਨੂੰ **`worker_threads`**, ਇੱਕ ਚਾਈਲਡ ਪ੍ਰੋਸੈਸ, ਜਾਂ ਇੱਕ ਕਤਾਰ (queue) ਵੱਲ ਭੇਜੋ ਤਾਂ ਜੋ event loop ਜਵਾਬਦੇਹ ਰਹੇ:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // ਇੱਕ ਵੱਖਰੇ ਥਰੈੱਡ ਉੱਤੇ ਚੱਲਦਾ ਹੈ
```

## ਵਿਹਾਰਕ ਨਿਯਮ

- ਸਰਵਰ ਉੱਤੇ ਬੇਨਤੀ ਹੈਂਡਲਰ ਦੇ ਅੰਦਰ ਕਦੇ ਵੀ `*Sync` API ਨਾ ਬੁਲਾਓ।
- ਗਰਮ ਰਾਹ (hot path) ਵਿੱਚ ਹਰ ਥਾਂ ਅਸਿੰਕ੍ਰੋਨਸ I/O ਵਰਤੋ।
- CPU-ਭਾਰੀ ਕੰਮ ਨੂੰ ਮੁੱਖ ਥਰੈੱਡ ਤੋਂ ਬਾਹਰ ਲੈ ਜਾਓ।
- ਅਚਾਨਕ ਬਲਾਕਿੰਗ ਤੋਂ ਸਾਵਧਾਨ ਰਹੋ: ਵੱਡਾ `JSON.parse`, ਸਿੰਕ੍ਰੋਨਸ ਕ੍ਰਿਪਟੋ, ਵਿਨਾਸ਼ਕਾਰੀ ਬੈਕਟ੍ਰੈਕਿੰਗ ਵਾਲੇ regex।

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

Node ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਮਾਡਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਇੱਕੋ-ਇੱਕ event-loop ਥਰੈੱਡ ਨੂੰ ਖਾਲੀ ਰੱਖਣ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇੱਕ ਅਵਾਰਾ ਬਲਾਕਿੰਗ ਕਾਲ — ਇੱਕ `readFileSync`, ਇੱਕ ਸਿੰਕ੍ਰੋਨਸ ਹੈਸ਼, ਇੱਕ ਹੌਲੀ regex — ਸਿਰਫ਼ ਉਸ ਬੇਨਤੀ ਨੂੰ ਹੀ ਨਹੀਂ ਜਿਸ ਨੇ ਇਸ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ, ਸਗੋਂ **ਹਰ** ਇੱਕੋ ਸਮੇਂ ਦੀ ਬੇਨਤੀ ਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ। ਕੀ ਬਲਾਕ ਕਰਦਾ ਹੈ ਅਤੇ ਕੀ ਨਹੀਂ, ਇਸ ਨੂੰ ਸਮਝਣਾ ਇੱਕ ਅਜਿਹੇ ਸਰਵਰ ਵਿੱਚ ਫ਼ਰਕ ਹੈ ਜੋ ਹਜ਼ਾਰਾਂ ਕੁਨੈਕਸ਼ਨਾਂ ਤੱਕ ਸਕੇਲ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਅਜਿਹੇ ਵਿੱਚ ਜੋ ਭਾਰ ਹੇਠ ਜੰਮ ਜਾਂਦਾ ਹੈ।

	ਬਲਾਕਿੰਗ	ਨਾਨ-ਬਲਾਕਿੰਗ
API ਸ਼ੈਲੀ	`*Sync` (`readFileSync`)	callback / Promise / `async`
ਥਰੈੱਡ	event loop ਨੂੰ ਰੋਕੀ ਰੱਖਦਾ ਹੈ	event loop ਨੂੰ ਖਾਲੀ ਕਰਦਾ ਹੈ
ਥਰੂਪੁੱਟ	ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਬੇਨਤੀ	ਇੱਕੋ ਸਮੇਂ ਕਈ ਬੇਨਤੀਆਂ
ਕਦੋਂ ਵਰਤੋ	ਸਟਾਰਟਅੱਪ/CLI ਸਕ੍ਰਿਪਟਾਂ	ਸਰਵਰ, ਬੇਨਤੀ ਹੈਂਡਲਰ

Node ਸਿੰਗਲ-ਥਰੈੱਡਡ ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਨਾਨ-ਬਲਾਕਿੰਗ ਕਿਉਂ ਹੈ

ਬਲਾਕਿੰਗ vs ਨਾਨ-ਬਲਾਕਿੰਗ

ਫੰਦਾ: CPU-ਬਾਊਂਡ ਕੰਮ ਫਿਰ ਵੀ ਬਲਾਕ ਕਰਦਾ ਹੈ

ਵਿਹਾਰਕ ਨਿਯਮ

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

ਸੰਬੰਧਿਤ ਸਵਾਲ