Kakšna je razlika med blokirajočimi in neblokirajočimi operacijami v Node.js?

Question

IT Interview Practice · Accepted Answer

**Blokirajoče** (blocking) operacije tečejo sinhrono in zadržijo edino nit JavaScripta, dokler se ne končajo — medtem se ne more izvajati nič drugega. **Neblokirajoče** (non-blocking) operacije začnejo delo, takoj vrnejo nadzor in rezultat dostavijo pozneje prek povratnega klica (callback), Promise ali dogodka, tako da nit ostane prosta za druge stvari.

## Zakaj je Node enonitni, a vseeno neblokirajoč

Vaš JavaScript teče na **eni** niti, ki jo poganja **zanka dogodkov** (event loop). V/I (datoteke, omrežje, DNS) je prepuščen **libuv**, ki pod pokrovom uporablja asinhrone zmogljivosti operacijskega sistema in majhen **bazen niti** (thread pool). Medtem ko to delo poteka zunaj niti, zanka dogodkov še naprej obdeluje druge povratne klice. Ko se V/I konča, se njegov povratni klic uvrsti v vrsto in izvede.

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

// Blocking: celoten proces tukaj čaka; nobena druga zahteva ni postrežena.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: takoj vrne nadzor; povratni klic se izvede, ko se V/I konča.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blokirajoče vs neblokirajoče

| | Blokirajoče | Neblokirajoče |
|---|---|---|
| Slog API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Nit | Zadrži zanko dogodkov | Sprosti zanko dogodkov |
| Prepustnost | Ena zahteva naenkrat | Veliko sočasnih zahtev |
| Uporabi kadar | Zagonski/CLI skripti | Strežniki, obravnavalniki zahtev |

## Past: delo, vezano na CPU, še vedno blokira

Neblokiranje pomaga le pri **V/I**. Težko sinhrono računanje (razčlenjevanje ogromnega JSON-payloada, kriptografija, spreminjanje velikosti slike, tesna zanka) blokira zanko dogodkov tudi znotraj funkcije `async`, ker se delo CPU-ja samo izvaja na niti JS.

```js
// Blokira zanko dogodkov za celotno zanko, čeprav je „async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // vezano na CPU, sinhrono
  return x;
}
```

Delo, vezano na CPU, prenesite v **`worker_threads`**, podrejeni proces ali vrsto, da zanka dogodkov ostane odzivna:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // teče na ločeni niti
```

## Praktična pravila

- Nikoli ne kličite API-jev `*Sync` znotraj obravnavalnika zahtev na strežniku.
- Asinhroni V/I uporabljajte povsod na vroči poti (hot path).
- Delo, ki močno obremenjuje CPU, prenesite z glavne niti.
- Pazite na naključno blokiranje: velik `JSON.parse`, sinhrona kriptografija, regularni izrazi s katastrofalnim vračanjem (backtracking).

## Zakaj je to pomembno

Model zmogljivosti Node je popolnoma odvisen od tega, da ostane edina nit zanke dogodkov prosta. En sam zablodel blokirajoč klic — `readFileSync`, sinhroni zgoščevalnik, počasen regex — zaustavi **vsako** sočasno zahtevo, ne le tiste, ki ga je sprožila. Razumevanje, kaj blokira in kaj ne, je razlika med strežnikom, ki se skalira na tisoče povezav, in takim, ki se pod obremenitvijo zamrzne.

	Blokirajoče	Neblokirajoče
Slog API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Nit	Zadrži zanko dogodkov	Sprosti zanko dogodkov
Prepustnost	Ena zahteva naenkrat	Veliko sočasnih zahtev
Uporabi kadar	Zagonski/CLI skripti	Strežniki, obravnavalniki zahtev

Zakaj je Node enonitni, a vseeno neblokirajoč

Blokirajoče vs neblokirajoče

Past: delo, vezano na CPU, še vedno blokira

Praktična pravila

Zakaj je to pomembno

Povezana vprašanja