Node.js मा blocking र non-blocking अपरेसनहरूबीच के फरक छ?

Question

IT Interview Practice · Accepted Answer

**Blocking** अपरेसनहरू synchronously चल्छन् र समाप्त नहुँदासम्म एउटै JavaScript thread लाई समातिराख्छन् — त्यसबेला अरू केही चल्न सक्दैन। **Non-blocking** अपरेसनहरूले काम सुरु गर्छन्, तुरुन्तै फर्किन्छन्, र नतिजा पछि callback, Promise, वा event मार्फत दिन्छन्, त्यसैले thread अन्य काम गर्न स्वतन्त्र रहन्छ।

## Node किन single-threaded हुँदाहुँदै पनि non-blocking छ

तपाईंको JavaScript **एउटै** thread मा चल्छ जसलाई **event loop** ले चलाउँछ। I/O (files, network, DNS) **libuv** लाई सुम्पिन्छ, जसले भित्रपट्टि OS का async सुविधा र सानो **thread pool** प्रयोग गर्छ। त्यो काम thread बाहिर हुँदा, event loop ले अन्य callbacks प्रशोधन गरिरहन्छ। I/O पूरा हुँदा, त्यसको callback लाई लाममा राखिन्छ र चलाइन्छ।

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

// Blocking: सम्पूर्ण प्रक्रिया यहाँ पर्खन्छ; अरू कुनै request सेवा हुँदैन।
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: तुरुन्तै फर्किन्छ; I/O सकिँदा callback चल्छ।
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking बनाम non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| API शैली | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | event loop समाति राख्छ | event loop मुक्त गर्छ |
| Throughput | एक पटकमा एउटा request | धेरै समवर्ती requests |
| कहिले प्रयोग गर्ने | Startup/CLI scripts | Servers, request handlers |

## पासो: CPU-bound काम अझै पनि block गर्छ

Non-blocking ले केवल **I/O** मा मात्र मद्दत गर्छ। भारी synchronous गणना (विशाल payload को JSON parsing, crypto, image resizing, कसिलो loop) ले `async` function भित्र पनि event loop लाई block गर्छ, किनभने CPU को काम आफैं JS thread मा चल्छ।

```js
// "async" भए पनि सम्पूर्ण loop भरि event loop block गर्छ।
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, synchronous
  return x;
}
```

CPU-bound काम **`worker_threads`**, child process, वा queue मा पन्छाउनुहोस् ताकि event loop प्रतिक्रियाशील रहोस्:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // छुट्टै thread मा चल्छ
```

## व्यावहारिक नियमहरू

- Server मा request handler भित्र कहिल्यै `*Sync` API नबोलाउनुहोस्।
- hot path मा सर्वत्र async I/O प्रयोग गर्नुहोस्।
- CPU-heavy काम main thread बाहिर सार्नुहोस्।
- आकस्मिक blocking बाट सचेत रहनुहोस्: ठूलो `JSON.parse`, synchronous crypto, catastrophic backtracking भएका regexes।

## यो किन महत्त्वपूर्ण छ

Node को performance मोडेल पूर्णतया एउटै event-loop thread लाई स्वतन्त्र राख्नमा निर्भर हुन्छ। एउटै बरालिएको blocking कल — एउटा `readFileSync`, एउटा synchronous hash, एउटा ढिलो regex — ले **हरेक** समवर्ती request लाई रोक्छ, केवल त्यसलाई ट्रिगर गर्ने मात्र होइन। के block गर्छ र के गर्दैन भन्ने बुझ्नु नै हजारौं connections सम्म स्केल हुने server र load तल जमेर बस्ने server बीचको फरक हो।

	Blocking	Non-blocking
API शैली	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	event loop समाति राख्छ	event loop मुक्त गर्छ
Throughput	एक पटकमा एउटा request	धेरै समवर्ती requests
कहिले प्रयोग गर्ने	Startup/CLI scripts	Servers, request handlers

Node किन single-threaded हुँदाहुँदै पनि non-blocking छ

Blocking बनाम non-blocking

पासो: CPU-bound काम अझै पनि block गर्छ

व्यावहारिक नियमहरू

यो किन महत्त्वपूर्ण छ

सम्बन्धित प्रश्नहरू