Yaushe da kuma yadda za ka yi amfani da wuraren jiya?

Question

Accepted Answer

**Wuraren jiya** ba su bada daidai da Node runan JavaScript akan **buɗe jiya** tare da gaskiya parallelism — magance babbar iyaka na Node: aiki mai nauyi CPU yana tabbatar da jiya ta gida (kuma don haka duk bukatun). Yi amfani da su don haƙƙa mai nauyi, ba don I/O ba (wanda loop-jiya ya na sakewa tare da inganci).

## Matsalar da suke warware

```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 ta aiki JS akan jiya daya. Haƙƙa mai tsawo synchronous ya tabbatar da **komai** — loop-jiya ba zai iya aiki da bukatun waje ba har sai lokacin da ya ƙare. Wuraren jiya sun yi aiki daga gida jiya.

## Yin amfani da wurar jiya

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

Wuraren ta aiki mai zafi; jiya ta gida ta ci gaba da jiran bukatun kuma ta sami sakamakon ta hanyar saƙo lokacin da aka gama.

## Yaushe za ka yi amfani (da a yi ba)

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

Azaba: **wurare don CPU-bound, loop-jiya don I/O-bound.**

## Wuraren jiya da child_process da 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
```

## Me take ya sa ya zama mahimmanci

Wuraren jiya sun magance babbar laƙabi na Node — aiki mai nauyi CPU-bound yana tabbatar da loop-jiya mai jiya daya kuma yana daskara duk bukatun juna.

Sanin ya bayar da aiki mai nauyi zuwa wurar (ci gaba da jiya ta gida ta samun hankali), kuma mahimman abin gareshi **yaushe** za ka yi amfani da su (CPU-bound kawai, ba sa I/O ba), shine abin da ya ba Node aikin sai ya dapat karɓar haƙƙa mai nauyi ba tare da yin aljihu ga jigon jitu-jitu na aiki wanda ke ba Node mahimmanci.

Masa samuwar wurare a saray, likitocin kamar Piscina suna sarrafa likita mai jiya tare da inganci.