तपाइँ worker threads कहिले र कसरी प्रयोग गर्नुहुन्छ?

Question

Accepted Answer

**Worker threads** Node लाई JavaScript **अलग threads** मा true parallelism सँग चलाउन दिन्छ — Node को सबैभन्दा ठूलो सीमितता समाधान गर्छ: CPU-intensive काम एकमात्र main thread लाई अवरोध गर्छ (र यसरी सबै requests)। भारी गणनाको लागि प्रयोग गर्नुहोस्, I/O को लागि नभई (जुन event loop पहिले नै कुशलतापूर्वक संभाल्छ)।

## समस्या जुन तिनीले समाधान गर्छ

```js
// ❌ this CPU-heavy work BLOCKS the event loop → all requests freeze for its duration
app.get("/hash", (req, res) => {
  const result = expensiveComputation(); // e.g. heavy crypto, image processing
  res.json(result); // meanwhile, no other request can be handled
});
```

Node तपाइँको JS एक thread मा चलाउछ। लामो synchronous गणना **सबैकुरा** अवरोध गर्छ — event loop अन्य requests प्रक्रिया गर्न सक्दैन जबसम्म यो समाप्त हुन्छ। Worker threads त्यो काम main thread बाहिर सार्छ।

## Worker thread प्रयोग गर्दै

```js
// main.js
import { Worker } from "worker_threads";

// the main thread stays free to handle other requests while this runs
const result = await runHeavyTask({ numbers: [...] });
```

```js
// worker.js — runs in parallel, on its own thread
import { workerData, parentPort } from "worker_threads";

const result = expensiveComputation(workerData); // doesn't block the main thread
parentPort.postMessage(result);                    // send the result back
```

Worker स्वतन्त्रतापूर्वक चलिरहेको छ; main thread requests सेवा गरिरहेको छ र सन्देशमार्फत परिणाम पाउँछ जब यो समाप्त हुन्छ।

## कहिले प्रयोग गर्नुहोस् (र कहिले होइन)

```text
✓ USE for CPU-bound work: image/video processing, encryption, compression,
  big data parsing, complex calculations, ML inference
✗ DON'T use for I/O (DB, files, HTTP) — the async event loop already handles
  that efficiently; a worker would add overhead for no benefit
```

नियम: **CPU-bound को लागि workers, I/O-bound को लागि event loop।**

## Worker threads vs child_process vs cluster

```text
worker_threads → share memory (efficient data passing), in-process threads — CPU work
child_process  → separate OS processes, run other programs — heavier isolation
cluster        → fork the whole server across CPUs — scale request handling
```

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

Worker threads Node को मूल कमजोरी सम्बोधन गर्छ — CPU-bound कार्य single-threaded event loop लाई अवरोध गर्छ र सबै एकसाथ requests लाई स्थिर गर्छ।

भारी गणना worker लाई सार्न जान्नु (main thread प्रतिक्रियाशील राख्दै), र महत्त्वपूर्ण रूपमा **कहिले** तिनीलाई प्रयोग गर्नुहोस् (केवल CPU-bound, I/O को लागि कहिले पनि होइन), यो हो जसले Node सेवालाई कहिले काहीं भारी प्रक्रिया सम्भाल्न दिन्छ लगभग Node लाई मूल्यवान बनाउने समवर्ती को त्याग बिना।

उत्पादनमा workers को pooling को लागि, Piscina जस्ता पुस्तकालयहरू thread pool लाई कुशलतापूर्वक व्यवस्थापन गर्छन्।