Când și cum folosești worker threads?

Question

Accepted Answer

**Worker threads** permit Node să ruleze JavaScript pe **fire separate** cu adevărat paralelism — rezolvând cea mai mare limitare a Node: munca CPU-intensivă blocând unicul fir principal (și prin urmare toate cererile). Folosește-le pentru calcule grele, nu pentru I/O (pe care event loop o gestionează deja eficient).

## De ce conteaza

```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-ul rulează JS-ul tău pe un singur fir. O computație sincronă lungă blochează **totul** — event loop nu poate procesa alte cereri până când se termină. Worker threads mută acea muncă din firul principal.

## Folosind un 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-ul rulează independent; firul principal continuă să deservească cererile și primește rezultatul printr-un mesaj când s-a terminat.

## Când să folosești (și când nu)

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

Regula: **worker threads pentru CPU-bound, event loop pentru I/O-bound.**

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

## De ce conteaza

Worker threads abordează punctul slab central al Node — sarcinile CPU-bound blocând event loop-ul single-threaded și înghețând toate cererile concurrente.

Știind cum să transferi calcule grele unui worker (ținând firul principal responsiv), și critic **când** să le folosești (doar CPU-bound, niciodată pentru I/O), este ceea ce permite unui serviciu Node să gestioneze ocazional procesare grea fără a sacrifica concurența care face Node valorosul.

Pentru pune in piscina worker threads în producție, biblioteci precum Piscina gestionează eficient un pool de fire.