Kuna tofauti gani kati ya operesheni za blocking na non-blocking katika Node.js?

Question

IT Interview Practice · Accepted Answer

Operesheni za **blocking** hufanya kazi kwa mfuatano (synchronously) na hushikilia thread pekee ya JavaScript hadi zimalize — hakuna kingine kinachoweza kufanya kazi wakati huo. Operesheni za **non-blocking** huanzisha kazi, hurudi mara moja, na hutoa matokeo baadaye kupitia callback, Promise, au event, hivyo thread hubaki huru kufanya mambo mengine.

## Kwa nini Node ina thread moja lakini bado ni non-blocking

JavaScript yako hukimbia kwenye thread **moja** inayoendeshwa na **event loop**. I/O (faili, mtandao, DNS) hukabidhiwa kwa **libuv**, ambayo hutumia huduma za asynchronous za OS na **thread pool** ndogo chini kwa chini. Wakati kazi hiyo inaendelea nje ya thread, event loop huendelea kushughulikia callbacks nyingine. I/O ikimalizika, callback yake hupangwa kwenye foleni na kukimbizwa.

```js
const fs = require("node:fs");

// Blocking: mchakato mzima husubiri hapa; hakuna request nyingine inayohudumiwa.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: hurudi mara moja; callback hukimbia I/O ikimalizika.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking dhidi ya non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| Mtindo wa API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | Hushikilia event loop | Huikomboa event loop |
| Kiwango cha upitishaji | Request moja kwa wakati | Requests nyingi kwa pamoja |
| Tumia wakati | Skripti za kuanzisha/CLI | Server, request handlers |

## Mtego: kazi ya CPU-bound bado hu-block

Non-blocking husaidia tu na **I/O**. Hesabu nzito ya synchronous (kuchambua JSON ya payload kubwa, crypto, kubadilisha ukubwa wa picha, loop iliyobana) hu-block event loop hata ndani ya function ya `async`, kwa sababu kazi ya CPU yenyewe hukimbia kwenye thread ya JS.

```js
// Hu-block event loop kwa loop nzima, licha ya kuwa "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, synchronous
  return x;
}
```

Hamisha kazi ya CPU-bound kwenda kwa **`worker_threads`**, child process, au foleni ili event loop ibaki inaitikia:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // hukimbia kwenye thread tofauti
```

## Kanuni za kimsingi

- Usiwahi kuita API za `*Sync` ndani ya request handler kwenye server.
- Tumia I/O ya asynchronous kila mahali kwenye njia ya moto (hot path).
- Hamisha kazi nzito ya CPU nje ya thread kuu.
- Jihadhari na blocking ya bahati mbaya: `JSON.parse` kubwa, crypto ya synchronous, regex zenye backtracking ya maafa.

## Kwa nini ni muhimu

Mfumo wa utendaji wa Node hutegemea kabisa kuweka thread pekee ya event loop ikiwa huru. Wito mmoja tu wa blocking uliopotea — `readFileSync`, hash ya synchronous, regex ya polepole — husimamisha **kila** request inayoendelea kwa pamoja, si tu ile iliyousababisha. Kuelewa kinachozuia na kisichozuia ndio tofauti kati ya server inayopanuka hadi maunganisho maelfu na ile inayoganda chini ya mzigo.

	Blocking	Non-blocking
Mtindo wa API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	Hushikilia event loop	Huikomboa event loop
Kiwango cha upitishaji	Request moja kwa wakati	Requests nyingi kwa pamoja
Tumia wakati	Skripti za kuanzisha/CLI	Server, request handlers

Kwa nini Node ina thread moja lakini bado ni non-blocking

Blocking dhidi ya non-blocking

Mtego: kazi ya CPU-bound bado hu-block

Kanuni za kimsingi

Kwa nini ni muhimu

Maswali yanayohusiana