Ni nini na jinsi gani unavyotumia worker threads?

Question

Accepted Answer

**Worker threads** huruhusu Node kueneza JavaScript kwenye **windo tofauti** na ulinganifu wa kweli — kutatua kuzuia kwa ajili ya Node: kazi yenye uzani wa CPU inayozuia windo kuu pekee (na hivyo maombi yote). Zitumie kwa hesabu nzito, si kwa I/O (ambayo event loop tayari inakamatia kwa ufanisi).

## Tatizo wanalotatua

```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 inaeneza JS yako kwenye windo moja. Hesabu ya synchronous ndefu inazuia **kila kitu** — event loop haiwezi kusindika maombi mengine hadi itakamilike. Worker threads huhamisha kazi hiyo kutoka kwa windo kuu.

## Kutumia windo la kazi

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

Kazi inaeneza kwa kujitegemea; windo kuu linaendelea kutumikia maombi na kupokea matokeo kupitia ujumbe wakati inapokamilika.

## Ni lini kutumia (na sio)

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

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

## Kwa nini inamaanisha

Worker threads zinatatuza wengo kuu la Node — kazi yenye muundo wa CPU inayozuia event loop yenye windo moja na kufianya sehemu zote zinazofanya kazi kukamatia.

Kujua kuhamisha hesabu nzito kwa kazi (kuweka windo kuu inayoreakti), na muhimu zaidi **lini** kutumia (CPU-bound tu, kamwe si kwa I/O), ndiyo inayoruhusu huduma ya Node kushughulikia usindikaji wa awhile nzito bila kusakrifisha ulinganifu ambao unaofanya Node kuwa faida.

Kwa kutengeneza windo katika uzalishaji, mabango kama Piscina yanasimamia bwawa la windo kwa ufanisi.