Kada ir kaip naudoti darbuotojo gijas?

Question

Accepted Answer

**Worker threads** leidžia Node paleisti JavaScript **atsiskirtose gijose** su tikruoju paralelizmu — sprendžiant didžiausią Node apribojimą: CPU-intensyvus darbas blokuoja vienintelę pagrindinę giją (ir taip visus užklausas). Naudokite sunkiam skaičiavimui, ne I/O operacijoms (kurias įvykio kilpa jau efektyviai tvarko).

## Problema, kurią jie sprendžia

```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 vykdo jūsų JS vienoje gijoje. Ilgą sinchroninį skaičiavimą blokuoja **viską** — įvykio kilpa negali apdoroti kitų užklausų, kol jis baigiasi. Worker gijos perkeliama darbą iš pagrindinės gijos.

## Darbuotojo gijos naudojimas

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

Darbuotojas veikia nepriklausomai; pagrindinė giją toliau aptarnauja užklausas ir gauna rezultatą per žinutę, kai jis baigtas.

## Kada naudoti (ir 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
```

Taisyklė: **darbai CPU-bound, įvykio kilpa I/O-bound.**

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

## Kodėl tai svarbu

Darbuotojo gijos sprendžia pagrindinį Node trūkumą — CPU-bound užduotys blokuoja vienos gijos įvykio kilpą ir užšaldo visas vienu metu atliekamas užklausas.

Žinoti, kaip perkelti sunkų skaičiavimą darbuotojui (išlaikant pagrindinę giją reaguojamą) ir labai svarbu **kada** juos naudoti (tik CPU-bound, niekada I/O), yra tai, kas leidžia Node paslaugai tvarkyti kartais sunkią apdorojimą nepažeidžiant lygiagretumo, dėl kurio Node yra vertinga.

Darbinių gijų maišymui gamyboje bibliotekos, tokios kaip Piscina, efektyviai valdo gijų baseiną.