Što je backpressure u tokovima i kako ga rukujete?

Question

Accepted Answer

**Backpressure** je ono što se događa kada se podaci proizvode **brže nego što ih je moguće konzumirati**. U tokovima, ako brz čitljiv izvor gura podatke u sporo pisljiv odredište, nekonzumirani podaci se baferiziraju u memoriji — a bez rukovanja, taj bafer raste dok se memorija ne iscrpi. Backpressure je mehanizam (i disciplina) za održavanje proizvođača i konzumenta u ravnoteži.

## Problem

```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
```

Primjer: brzo čitanje ogromne datoteke i pisanje je u spor mrežni soket ili disk — ako ne poštujete brzinu odredišta, memorija se preplavljuje.

## pipe automatski rukuje backpressurom

```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"));
```

Ovo je glavni razlog korištenja `pipe`/`pipeline`: oni upravljaju backpressurom za vas, pauziraju i nastavljaju tok kako bi memorija ostala ograničena bez obzira na neslaganje veličine.

## Ručno rukovanje s povratnom vrijednosti 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
  }
});
```

Ako ručno rukujete tokovima, pravilo je: kada `writable.write()` vraća `false`, **pauzurajte** čitljivo, i **nastavljajte** ga na `drain` događaj pisljavog. Ignorirajući povratnu vrijednost `false` je klasična greška backpressure.

## S async iteracijom (moderna, čista)

```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
}
```

## Preferiraj pipeline radi sigurnosti

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

## Zašto je važno

Backpressure je suptilan ali kritičan koncept za bilo koju intenzivnu Node uslugu s podacima (obrada datoteka, proxy, streaming, ETL).

Ignorirajući ga — baferiziranjem svega ili ignoriranjem povratne vrijednosti `write()` — uzrokuje neograničen rast memorije i rušenja pod opterećenjem, često samo u proizvodnji s velikim podacima.

Razumijevanje da `pipe`/`pipeline` to automatski rukuju (glavni razlog da ih preferirate), i kako to ručno poštovati (pauzurajte na `false`, nastavljajte na `drain`) ili preko `for await`, jest ono što vam omogućava izgradnju sistema tokova koji ostaju memorijski stabilni bez obzira na to koliko su veliki ili brzi podaci.

To je karakteristična znamenka kompetentne uporabe tokova.