Menene bambanci tsakanin ayyukan blocking da non-blocking a Node.js?

Question

IT Interview Practice · Accepted Answer

Ayyukan **blocking** suna gudana ta hanyar synchronous kuma suna riƙe da guda ɗaya na JavaScript thread har sai sun gama — babu wani abu da zai iya gudana a wannan lokacin. Ayyukan **non-blocking** suna fara aikin, su dawo nan take, sannan su isar da sakamako daga baya ta hanyar callback, Promise, ko event, don haka thread ɗin ya kasance a shirye don yin wasu abubuwa.

## Me ya sa Node yake da thread guda ɗaya amma duk da haka non-blocking

JavaScript naka yana gudana a kan thread **guda ɗaya** wanda **event loop** ke tuƙa shi. Ana ba da I/O (fayiloli, cibiyar sadarwa, DNS) ga **libuv**, wanda yake amfani da kayan aikin async na OS da wani ƙaramin **thread pool** a ɓoye. Yayin da wannan aikin yake faruwa a wajen thread, event loop yana ci gaba da sarrafa sauran callbacks. Idan I/O ya gama, ana jera callback ɗinsa a layi sannan a gudanar da shi.

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

// Blocking: dukan tsari yana jira a nan; babu wani buƙata da ake biya masa buƙata.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: yana dawowa nan take; callback yana gudana idan I/O ya gama.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking vs non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| Salon API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Thread | Yana riƙe event loop | Yana 'yantar da event loop |
| Yawan aiki | Buƙata ɗaya a lokaci guda | Buƙatu da yawa a lokaci guda |
| A yi amfani idan | Rubutun farawa/CLI | Sabar, masu sarrafa buƙata |

## Tarko: aikin CPU-bound har yanzu yana blocking

Non-blocking yana taimako da **I/O** kaɗai. Wani lissafi mai nauyi na synchronous (parsing na JSON na babban payload, crypto, sake girman hoto, madauwari mai matsi) yana blocking event loop ko da a cikin aikin `async`, saboda aikin CPU da kansa yana gudana a kan JS thread.

```js
// Yana blocking event loop na dukan madauwari, duk da yake an sa masa "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-bound, synchronous
  return x;
}
```

Mayar da aikin CPU-bound zuwa **`worker_threads`**, wani child process, ko wani queue don event loop ya kasance mai amsawa:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // yana gudana a kan thread daban
```

## Ka'idojin gama-gari

- Kada ka taɓa kiran `*Sync` APIs a cikin mai sarrafa buƙata a kan sabar.
- Yi amfani da async I/O ko'ina a kan hanya mai zafi (hot path).
- Cire aikin CPU mai nauyi daga babban thread.
- Ka yi lura da blocking na kwatsam: babban `JSON.parse`, synchronous crypto, regex mai backtracking mai bala'i.

## Me ya sa yake da muhimmanci

Samfurin aiki na Node ya dogara gaba ɗaya kan riƙe thread ɗaya na event-loop a 'yance. Kira guda ɗaya na blocking da ya ɓace — `readFileSync`, hash na synchronous, regex mai jinkiri — yana tsayar da **kowace** buƙata da take gudana a lokaci guda, ba wai kawai wadda ta jawo shi ba. Fahimtar abin da yake blocking da abin da ba ya blocking shi ne bambanci tsakanin sabar da take faɗaɗa zuwa dubban haɗin gwiwa da wadda take daskarewa a ƙarƙashin nauyi.

	Blocking	Non-blocking
Salon API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Thread	Yana riƙe event loop	Yana 'yantar da event loop
Yawan aiki	Buƙata ɗaya a lokaci guda	Buƙatu da yawa a lokaci guda
A yi amfani idan	Rubutun farawa/CLI	Sabar, masu sarrafa buƙata

Me ya sa Node yake da thread guda ɗaya amma duk da haka non-blocking

Blocking vs non-blocking

Tarko: aikin CPU-bound har yanzu yana blocking

Ka'idojin gama-gari

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa