Co je backpressure v streams a jak ji řešíte?

Question

Accepted Answer

**Backpressure** je to, co se stane, když jsou data produkována **rychleji, než mohou být spotřebována**. V streams, pokud rychlý zdroj čtení tlačí data do pomalého cíle zápisu, nespotřebená data se ukládají do vyrovnávací paměti — a bez zpracování se tato vyrovnávací paměť rozrůstá, dokud paměť není vyčerpána. Backpressure je mechanismus (a disciplína) pro udržení rovnováhy mezi producenter a spotřebitelem.

## Problém

```text
Fast source ──(1 GB/s)──▶ Slow destination (10 MB/s write speed)
                          ▲
             The 990 MB/s difference piles up in a memory buffer → OOM crash
```

Příklad: čtení obřího souboru rychle a zápis na pomalý síťový socket nebo disk — pokud nerespektujete tempo cíle, paměť se rozroste příliš.

## pipe automaticky řeší backpressure

```js
import { createReadStream, createWriteStream } from "fs";

// ✅ pipe automatically pauses the source when the destination is full,
//    and resumes it when the destination drains — backpressure handled for you
createReadStream("huge.file").pipe(createWriteStream("copy.file"));
```

Toto je hlavní důvod, proč používat `pipe`/`pipeline`: spravují backpressure za vás, pozastavují a obnovují tok, aby paměť zůstala omezená bez ohledu na nesoulad velikostí.

## Ruční zpracování s pomocí vrácené hodnoty write()

```js
// write() returns FALSE when the internal buffer is full — that's the backpressure signal
readable.on("data", (chunk) => {
  const ok = writable.write(chunk);
  if (!ok) {
    readable.pause();                       // stop reading — destination is full
    writable.once("drain", () => readable.resume()); // resume when it drains
  }
});
```

Pokud streams zpracováváte ručně, pravidlo je: když `writable.write()` vrátí `false`, **pozastavte** čtení a **obnovte** ho na `drain` eventu writable. Ignorování vrácené `false` je klasický backpressure bug.

## S async iteration (moderní, čisté)

```js
// for-await respects backpressure naturally — it awaits each chunk's processing
for await (const chunk of readable) {
  await processSlowly(chunk); // only pulls the next chunk when ready
}
```

## Upřednostňujte pipeline pro bezpečnost

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + error handling + cleanup
```

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

Backpressure je jemný, ale kritický koncept pro jakoukoli datově náročnou Node službu (zpracování souborů, proxy, streaming, ETL).

Ignorace — ukládáním všeho do vyrovnávací paměti nebo ignorováním vrácené hodnoty `write()` — způsobuje neomezený růst paměti a pády pod zátěží, často pouze v produkci s velkými daty.

Chápání, že `pipe`/`pipeline` to řeší automaticky (hlavní důvod, proč je preferovat), a jak to respektovat ručně (pozastavit na `false`, obnovit na `drain`) nebo prostřednictvím `for await`, vám umožní vytvářet systémy streamů, které zůstávají stabilní v paměti bez ohledu na to, jak velká nebo rychlá data jsou.

Je to definující znak kompetentního používání streamů.