Jaký je rozdíl mezi blokujícími a neblokujícími operacemi v Node.js?

Question

IT Interview Practice · Accepted Answer

**Blokující** operace běží synchronně a drží jediné vlákno JavaScriptu, dokud neskončí — mezitím nemůže běžet nic jiného. **Neblokující** operace práci zahájí, okamžitě se vrátí a výsledek doručí později přes callback, Promise nebo událost, takže vlákno zůstává volné pro jinou práci.

## Proč je Node jednovláknový, a přesto neblokující

Váš JavaScript běží na **jednom** vlákně řízeném **event loopem**. I/O (soubory, síť, DNS) je delegováno na **libuv**, který pod kapotou využívá asynchronní prostředky OS a malý **thread pool**. Zatímco tato práce probíhá mimo vlákno, event loop dál zpracovává další callbacky. Když se I/O dokončí, jeho callback se zařadí do fronty a spustí.

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

// Blocking: celý proces zde čeká; žádný jiný požadavek není obsloužen.
const data = fs.readFileSync("big.json");
console.log("done reading");

// Non-blocking: vrací se okamžitě; callback se spustí, když I/O skončí.
fs.readFile("big.json", (err, data) => {
  console.log("done reading");
});
console.log("this logs first");
```

## Blokující vs neblokující

| | Blocking | Non-blocking |
|---|---|---|
| Styl API | `*Sync` (`readFileSync`) | callback / Promise / `async` |
| Vlákno | Drží event loop | Uvolňuje event loop |
| Propustnost | Jeden požadavek naráz | Mnoho souběžných požadavků |
| Použij když | Startovací/CLI skripty | Servery, handlery požadavků |

## Past: práce vázaná na CPU stále blokuje

Neblokování pomáhá jen u **I/O**. Náročný synchronní výpočet (parsování obřího JSON payloadu, kryptografie, změna velikosti obrázku, těsná smyčka) blokuje event loop i uvnitř `async` funkce, protože samotná práce CPU běží na vlákně JS.

```js
// Blokuje event loop po celou smyčku, přestože je "async".
async function hash(n) {
  let x = 0;
  for (let i = 0; i < n; i++) x += Math.sqrt(i); // vázané na CPU, synchronní
  return x;
}
```

Přesuňte práci vázanou na CPU do **`worker_threads`**, podprocesu (child process) nebo fronty, aby event loop zůstal responzivní:

```js
const { Worker } = require("node:worker_threads");
new Worker("./cpu-task.js"); // běží na samostatném vlákně
```

## Praktická pravidla

- Nikdy nevolejte `*Sync` API uvnitř handleru požadavku na serveru.
- Používejte asynchronní I/O všude na horké cestě (hot path).
- Přesuňte práci náročnou na CPU mimo hlavní vlákno.
- Dávejte pozor na náhodné blokování: velký `JSON.parse`, synchronní kryptografie, regexy s katastrofickým backtrackingem.

## Proč je to důležité

Výkonový model Node zcela závisí na tom, že jediné vlákno event loopu zůstane volné. Jediné zbloudilé blokující volání — `readFileSync`, synchronní hash, pomalý regex — zastaví **každý** souběžný požadavek, nejen ten, který ho vyvolal. Pochopení toho, co blokuje a co ne, je rozdíl mezi serverem, který škáluje na tisíce spojení, a serverem, který zamrzne pod zátěží.

	Blocking	Non-blocking
Styl API	`*Sync` (`readFileSync`)	callback / Promise / `async`
Vlákno	Drží event loop	Uvolňuje event loop
Propustnost	Jeden požadavek naráz	Mnoho souběžných požadavků
Použij když	Startovací/CLI skripty	Servery, handlery požadavků

Proč je Node jednovláknový, a přesto neblokující

Blokující vs neblokující

Past: práce vázaná na CPU stále blokuje

Praktická pravidla

Proč je to důležité

Související otázky