Milloin ja miten käytät worker threadeja?

Question

Accepted Answer

**Worker threadit** antavat Nodelle mahdollisuuden ajaa JavaScriptiä **erillisillä threadilla** todellisella rinnakkaisuudella — ratkaisu Noden suurimpaan rajoitukseen: CPU-intensiivinen työ estää ainoan pääthreadin (ja siten kaikki pyynnöt). Käytä niitä raskaiden laskelmien kanssa, ei I/O:n kanssa (jonka event loop jo käsittelee tehokkaasti).

## Ongelma, jonka ne ratkaisevat

```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 ajaa JS:ääsi yhdellä threadilla. Pitkä synkroninen laskenta estää **kaiken** — event loop ei voi käsitellä muita pyyntöjä ennen kuin se päättyy. Worker threadit siirtävät työn pois pääthreadista.

## Worker threadin käyttö

```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 ajaa itsenäisesti; pääthread jatkaa pyyntöjen palvelua ja saa tuloksen viestin kautta kun se valmistuu.

## Milloin käyttää (ja milloin ei)

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

Sääntö: **worker threadit CPU-rajoitetuille tehtäville, event loop I/O-rajoitetuille tehtäville.**

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

## Miksi sillä on väliä

Worker threadit ratkaisevat Noden perusheikkouden — CPU-rajoittuneet tehtävät estävät yhden säikeen event loopin ja pakottavat kaikki samanaikaiset pyynnöt odottamaan.

Tieto siitä, että raskaat laskelmat on siirrettävä workerille (pääthreadin pitämiseksi responsiivisena), ja ratkaisevasti **milloin** niitä tulee käyttää (vain CPU-rajoittuneet, ei koskaan I/O:n kanssa), on se, mikä mahdollistaa Node-palvelun käsittelemään ajoittaista raskasta käsittelyä ilman Noden arvokkaan rinnakkaisuuden uhrausta.

Workerien poolingia varten tuotannossa kirjastot kuten Piscina hallitsevat thread poolia tehokkaasti.