Kdy a jak používáte worker threads?

Question

Accepted Answer

**Worker threads** umožňují Node spouštět JavaScript na **oddělených threadech** se skutečným paralelismem — řešení největšího omezení Node: CPU-náročná práce blokující jediné hlavní vlákno (a tím pádem všechny požadavky). Používejte je pro těžké výpočty, ne pro I/O (které event loop již efektivně zpracovává).

## Problém, který řeší

```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 spouští váš JS na jednom vlákně. Dlouhý synchronní výpočet blokuje **všechno** — event loop nemůže zpracovávat jiné požadavky, dokud se neskončí. Worker threads přesunují tuto práci mimo hlavní vlákno.

## Použití 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 běží nezávisle; hlavní vlákno pokračuje v obsluze požadavků a získá výsledek prostřednictvím zprávy po dokončení.

## Kdy používat (a kdy ne)

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

Pravidlo: **workers pro CPU-bound, event loop pro 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
```

## Proč na tom záleží

Worker threads řeší základní slabinu Node — CPU-bound úkoly blokují jednoprocesorový event loop a zamrazují všechny souběžné požadavky.

Vědět, jak přenést těžké výpočty do workeru (aby hlavní vlákno zůstalo responzivní), a kriticky **kdy** je používat (pouze CPU-bound, nikdy ne pro I/O), je to, co umožňuje Node službě zvládat příležitostné těžké zpracování bez obětování souběžnosti, která dělá Node cenným.

Pro sdružování workerů v produkci bibliotheke jako Piscina efektivně spravují thread pool.