Kuo skiriasi blokuojančios ir neblokuojančios operacijos Node.js?

Question

IT Interview Practice · Accepted Answer

**Blokuojančios** operacijos vykdomos sinchroniškai ir laiko vienintelę JavaScript giją, kol nesibaigia — tuo metu niekas kitas vykti negali. **Neblokuojančios** operacijos pradeda darbą, iškart grąžina valdymą, o rezultatą pateikia vėliau per callback, Promise ar event, todėl gija lieka laisva kitiems darbams.

## Kodėl Node yra vienagijis, bet neblokuojantis

Jūsų JavaScript vykdomas **vienoje** gijoje, kurią valdo **event loop**. I/O (failai, tinklas, DNS) perduodamas **libuv**, kuris po dangčiu naudoja OS asinchronines priemones ir nedidelį **thread pool**. Kol tas darbas vyksta už gijos ribų, event loop toliau apdoroja kitus callback'us. Kai I/O baigiasi, jo callback įrašomas į eilę ir įvykdomas.

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

// Blokuojantis: visas procesas laukia čia; joks kitas request neaptarnaujamas.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Neblokuojantis: grąžina iškart; callback įvykdomas, kai I/O baigiasi.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blokuojančios ir neblokuojančios

| | Blokuojančios | Neblokuojančios |
|---|---|---|
| API stilius | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Gija | Laiko event loop | Atlaisvina event loop |
| Pralaidumas | Vienas request vienu metu | Daug lygiagrečių request |
| Naudoti kai | Paleidimo/CLI skriptai | Serveriai, request handleriai |

## Spąstai: CPU imlus darbas vis tiek blokuoja

Neblokuojantis būdas padeda tik su **I/O**. Sunkus sinchroninis skaičiavimas (didžiulio payload JSON parsinimas, kriptografija, paveikslėlių dydžio keitimas, ankšta ciklo kilpa) blokuoja event loop net `async` funkcijos viduje, nes pats CPU darbas vykdomas JS gijoje.

```js
// Blokuoja event loop visą ciklą, nors ir pažymėta „async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // CPU imlus, sinchroninis
  return x;
}
```

Perkelkite CPU imlų darbą į **`worker_threads`**, child process arba eilę, kad event loop liktų reaguojantis:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // vykdoma atskiroje gijoje
```

## Nykščio taisyklės

- Niekada nekvieskite `*Sync` API serverio request handlerio viduje.
- Naudokite asinchroninį I/O visur karštajame kelyje (hot path).
- Perkelkite CPU imlų darbą iš pagrindinės gijos.
- Saugokitės atsitiktinio blokavimo: didelis `JSON.parse`, sinchroninė kriptografija, regex su katastrofišku backtracking.

## Kodėl tai svarbu

Node našumo modelis visiškai priklauso nuo to, ar vienintelė event loop gija lieka laisva. Vienas paklydęs blokuojantis kvietimas — `readFileSync`, sinchroninis hash, lėtas regex — sustabdo **kiekvieną** lygiagretų request, ne tik tą, kuris jį sukėlė. Suprasti, kas blokuoja, o kas ne, yra skirtumas tarp serverio, kuris išsiplečia iki tūkstančių jungčių, ir serverio, kuris užstringa esant apkrovai.

	Blokuojančios	Neblokuojančios
API stilius	`*Sync` (`readFileSync`)	callback / Promise / `async`
Gija	Laiko event loop	Atlaisvina event loop
Pralaidumas	Vienas request vienu metu	Daug lygiagrečių request
Naudoti kai	Paleidimo/CLI skriptai	Serveriai, request handleriai

Kodėl Node yra vienagijis, bet neblokuojantis

Blokuojančios ir neblokuojančios

Spąstai: CPU imlus darbas vis tiek blokuoja

Nykščio taisyklės

Kodėl tai svarbu

Susiję klausimai