Kapan lan priksa cara nggunakake worker threads?

Question

Accepted Answer

**Worker threads** ngidini Node nglakokake JavaScript ing **thread terpisah** kanthi paralelisme nyata — ngatasi kelemahan paling gedhe Node: pekerjaan sing ngeyot CPU ngalangi single main thread (lan mula kabeh requests). Gunakake kanggo komputasi berat, ora kanggo I/O (sing event loop wis nangani kanthi efisien).

## Masalah sing diatasi

```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 nglakokake JS mu ing siji thread. Komputasi sinkron sing dawa ngalangi **kabeh** — event loop ora bisa ngolah requests liyane nganti rampung. Worker threads mindhah pekerjaan iku menyang thread liyane.

## Nggunakake 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 nglakokake kanthi mandiri; main thread terus ngayani requests lan nampa hasil lewat message nalika rampung.

## Kapan nggunakake (lan ora)

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

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

## Apa gunane

Worker threads ngatasi kalemahan inti Node — tugas CPU-bound ngalangi single-threaded event loop lan membekukan kabeh requests bebarengan.

Weruhe kudu mindhah komputasi berat menyang worker (nahanake main thread tetep responsif), lan terutama **kapan** nggunakake (CPU-bound mung, ora nganti kanggo I/O), yaiku sing ngidini layanan Node nangani pemrosesan berat kadang-kadang tanpa ngorbanake concurrency sing nggawe Node berharga.

Kanggo pooling workers ing produksi, perpustakaan kaya Piscina ngelola thread pool kanthi efisien.