Cén difríocht atá idir oibríochtaí blocking agus non-blocking in Node.js?

Question

IT Interview Practice · Accepted Answer

Ritheann oibríochtaí **blocking** go sioncronach agus coinníonn siad greim ar an aon snáithe JavaScript amháin go dtí go gcríochnaíonn siad — ní féidir le haon rud eile rith idir an dá linn. Cuireann oibríochtaí **non-blocking** tús leis an obair, filleann siad láithreach, agus seachadann siad an toradh níos déanaí trí callback, Promise, nó imeacht, mar sin fanann an snáithe saor chun rudaí eile a dhéanamh.

## Cén fáth a bhfuil Node aon-snáithithe ach fós non-blocking

Ritheann do JavaScript ar **aon** snáithe amháin a stiúrann an **event loop**. Déantar I/O (comhaid, líonra, DNS) a tharmligean chuig **libuv**, a úsáideann áiseanna async an chórais oibriúcháin agus **thread pool** beag faoin gclúdach. Fad a tharlaíonn an obair sin lasmuigh den snáithe, leanann an event loop ar aghaidh ag próiseáil callbacks eile. Nuair a chríochnaíonn an I/O, cuirtear a callback sa scuaine agus ritear é.

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

// Blocking: fanann an próiseas iomlán anseo; ní fhreastalaítear ar aon iarratas eile.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: filleann láithreach; ritheann an callback nuair a chríochnaíonn an I/O.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blocking vs non-blocking

| | Blocking | Non-blocking |
|---|---|---|
| Stíl API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Snáithe | Coinníonn an event loop | Scaoileann an event loop |
| Tréchur | Iarratas amháin ag an am | Go leor iarratas comhuaineach |
| Úsáid nuair | Scripteanna tosaithe/CLI | Freastalaithe, láimhseálaithe iarratas |

## An gaiste: blocálann obair CPU-cheangailte fós

Ní chabhraíonn non-blocking ach le **I/O**. Cuireann ríomh sioncronach trom (parsáil JSON ar phálasta ollmhór, cripteagrafaíocht, athrú méide íomhá, lúb dhlúth) bac ar an event loop fiú taobh istigh d'fheidhm `async`, mar go ritheann an obair CPU féin ar an snáithe JS.

```js
// Blocálann sé an event loop don lúb ar fad, in ainneoin é a bheith "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU-cheangailte, sioncronach
  return x;
}
```

Aistrigh obair CPU-cheangailte chuig **`worker_threads`**, próiseas linbh, nó scuaine ionas go bhfanann an event loop freagrúil:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // ritheann ar snáithe ar leith
```

## Rialacha ordóige

- Ná glaoigh riamh ar API `*Sync` taobh istigh de láimhseálaí iarratais ar fhreastalaí.
- Úsáid I/O async i ngach áit ar an gcosán te (hot path).
- Bog obair throm CPU amach ón bpríomhshnáithe.
- Bí ar an airdeall roimh bhlocáil de thaisme: `JSON.parse` mór, cripteagrafaíocht sioncronach, regex le cúlrianú tubaisteach.

## Cén fáth a bhfuil sé tábhachtach

Braitheann samhail feidhmíochta Node go hiomlán ar an aon snáithe event-loop amháin a choinneáil saor. Stopann aon ghlao blocking amháin ar strae — `readFileSync`, hais sioncronach, regex mall — **gach** iarratas comhuaineach, ní hamháin an ceann a spreag é. Is í an tuiscint ar cad a bhlocálann agus cad nach mblocálann an difríocht idir freastalaí a scálaíonn go dtí na mílte nasc agus ceann a reoann faoi ualach.

	Blocking	Non-blocking
Stíl API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Snáithe	Coinníonn an event loop	Scaoileann an event loop
Tréchur	Iarratas amháin ag an am	Go leor iarratas comhuaineach
Úsáid nuair	Scripteanna tosaithe/CLI	Freastalaithe, láimhseálaithe iarratas

Cén fáth a bhfuil Node aon-snáithithe ach fós non-blocking

Blocking vs non-blocking

An gaiste: blocálann obair CPU-cheangailte fós

Rialacha ordóige

Cén fáth a bhfuil sé tábhachtach

Ceisteanna gaolmhara