Koja je razlika između blokirajućih (blocking) i neblokirajućih (non-blocking) operacija u Node.js-u?

Question

IT Interview Practice · Accepted Answer

**Blokirajuće** operacije izvode se sinkrono i drže jedinu JavaScript nit dok ne završe — u međuvremenu ništa drugo ne može raditi. **Neblokirajuće** operacije pokreću posao, odmah se vraćaju i rezultat isporučuju kasnije putem callbacka, Promisea ili eventa, pa nit ostaje slobodna za druge stvari.

## Zašto je Node jednonitni, a ipak neblokirajući

Tvoj JavaScript izvodi se na **jednoj** niti kojom upravlja **event loop**. I/O (datoteke, mreža, DNS) delegira se **libuv**-u, koji ispod haube koristi asinkrone mehanizme OS-a i mali **thread pool**. Dok se taj posao odvija izvan niti, event loop nastavlja obrađivati druge callbackove. Kad se I/O dovrši, njegov callback stavlja se u red i izvršava.

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

// Blokirajuće: cijeli proces čeka ovdje; nijedan drugi zahtjev nije poslužen.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Neblokirajuće: vraća se odmah; callback se izvršava kad I/O završi.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blokirajuće vs neblokirajuće

| | Blokirajuće | Neblokirajuće |
|---|---|---|
| Stil API-ja | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Nit | Drži event loop | Oslobađa event loop |
| Propusnost | Jedan zahtjev odjednom | Mnogo istovremenih zahtjeva |
| Koristi kada | Startup/CLI skripte | Serveri, obrađivači zahtjeva |

## Zamka: posao vezan uz CPU i dalje blokira

Neblokiranje pomaže samo kod **I/O**-a. Teško sinkrono računanje (JSON parsiranje ogromnog payloada, kriptografija, promjena veličine slike, tijesna petlja) blokira event loop čak i unutar `async` funkcije, jer se sam CPU posao izvodi na JS niti.

```js
// Blokira event loop tijekom cijele petlje, unatoč tome što je "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // vezano uz CPU, sinkrono
  return x;
}
```

Prebaci posao vezan uz CPU na **`worker_threads`**, child proces ili red kako bi event loop ostao responzivan:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // izvodi se na zasebnoj niti
```

## Pravila iskustva

- Nikad ne pozivaj `*Sync` API-je unutar obrađivača zahtjeva na serveru.
- Koristi asinkroni I/O svugdje na vrućoj putanji (hot path).
- Premjesti CPU-intenzivan posao izvan glavne niti.
- Pazi na slučajno blokiranje: velik `JSON.parse`, sinkrona kriptografija, regexi s katastrofalnim backtrackingom.

## Zašto je to važno

Nodeov model performansi u potpunosti ovisi o tome da jedina nit event loopa ostane slobodna. Jedan zalutali blokirajući poziv — `readFileSync`, sinkroni hash, spor regex — zaustavlja **svaki** istovremeni zahtjev, ne samo onaj koji ga je pokrenuo. Razumijevanje što blokira, a što ne, razlika je između servera koji se skalira na tisuće veza i onoga koji se zamrzne pod opterećenjem.

	Blokirajuće	Neblokirajuće
Stil API-ja	`*Sync` (`readFileSync`)	callback / Promise / `async`
Nit	Drži event loop	Oslobađa event loop
Propusnost	Jedan zahtjev odjednom	Mnogo istovremenih zahtjeva
Koristi kada	Startup/CLI skripte	Serveri, obrađivači zahtjeva

Zašto je Node jednonitni, a ipak neblokirajući

Blokirajuće vs neblokirajuće

Zamka: posao vezan uz CPU i dalje blokira

Pravila iskustva

Zašto je to važno

Povezana pitanja