તમે વર્કર થ્રેડ્સનો ક્યારે અને કેવી રીતે ઉપયોગ કરો છો?

Question

Accepted Answer

**વર્કર થ્રેડ્સ** Node ને **અલગ થ્રેડ્સ** પર JavaScript ચલાવવા દે છે અને સાચી સમાંતરતા સાથે — Node ની સૌથી મોટી મર્યાદાનું સમાધાન: CPU-ઘન કાર્ય મુખ્ય થ્રેડને અવરોધિત કરે છે (અને તેથી બધી વિનંતીઓ). તેમનો ઉપયોગ ભારે ગણતરી માટે કરો, I/O માટે નહીં (જે ઇવેન્ટ લૂપ પહેલેથી જ કાર્યક્ષમતાથી સંભાળે છે).

## સમસ્યા જે તેઓ હલ કરે છે

```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 એક થ્રેડ પર ચલાવે છે. લાંબી સિંક્રોનસ ગણતરી **બધું** અવરોધિત કરે છે — ઇવેન્ટ લૂપ અન્ય વિનંતીઓ પર પ્રક્રિયા કરી શકતો નથી જ્યાં સુધી તે સમાપ્ત ન થાય. વર્કર થ્રેડ્સ તે કાર્યને મુખ્ય થ્રેડ પરથી દૂર લઈ જાય છે।

## વર્કર થ્રેડનો ઉપયોગ કરવો

```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
```

વર્કર સ્વતંત્રપણે ચાલે છે; મુખ્ય થ્રેડ વિનંતીઓ પર સેવા આપવાનું ચાલુ રાખે છે અને તે કર્યા બાદ સંદેશ દ્વારા પરિણામ પ્રાપ્ત કરે છે.

## ક્યારે ઉપયોગ કરવો (અને નહીં)

```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-સંબંધિત માટે વર્કર્સ, I/O-સંબંધિત માટે ઇવેન્ટ લૂપ।**

## વર્કર થ્રેડ્સ વિરુદ્ધ child_process વિરુદ્ધ 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
```

## કેમ તે મહત્વપૂર્ણ છે

વર્કર થ્રેડ્સ Node ની મુખ્ય નબળાઈને સંબોધિત કરે છે — CPU-સંબંધિત કાર્યો એક-થ્રેડેડ ઇવેન્ટ લૂપને અવરોધિત કરે છે અને તમામ સમવર્તી વિનંતીઓને ફ્રીજ કરે છે.

ભારે ગણતરીને વર્કર પર હટાવવાનું જાણવું (મુખ્ય થ્રેડને પ્રતિક્રિયાશીલ રાખીને), અને નિર્ણયપૂર્વક **ક્યારે** તેમનો ઉપયોગ કરવો (માત્ર CPU-સંબંધિત, ક્યારેય I/O માટે નહીં), તે જ છે જે Node સેવાને આવતીકાલ ભારે પ્રક્રિયા સંભાળતા વિના Node ને મૂલ્યવાન બનાવતી સમવર્તનતાનું બલિદાન આપ્યા વિના.

ઉત્પાદનમાં વર્કર્સને પૂલ કરવા માટે, Piscina જેવી લાઇબ્રેરીઓ થ્રેડ પૂલને કાર્યક્ષમતાથી સંચાલિત કરે છે।