Co to backpressure w streamach i jak się go obsługuje?

Question

Accepted Answer

**Backpressure** to sytuacja, gdy dane są produkowane **szybciej niż mogą być konsumowane**. W streamach, jeśli szybkie źródło czytelne wypycha dane do wolnego miejsca docelowego do zapisu, niekonsumowane dane zbierają się w buforze w pamięci — i bez obsługi ten bufor rośnie aż pamięć się wyczerpie. Backpressure to mechanizm (i dyscyplina) utrzymujący producenta i konsumenta w równowadze.

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

Przykład: szybkie czytanie ogromnego pliku i zapis do wolnego socketu sieciowego lub dysku — jeśli nie respektujesz tempa docelowego, pamięć zdecydowanie rośnie.

## pipe obsługuje backpressure automatycznie

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

To główny powód, aby używać `pipe`/`pipeline`: automatycznie zarządzają backpressure, wstrzymując i wznawiając przepływ, aby pamięć pozostała ograniczona niezależnie od niezgodności rozmiarów.

## Obsługa manualna z wartością zwracaną przez 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
  }
});
```

Jeśli obsługujesz streamy ręcznie, zasada jest: gdy `writable.write()` zwraca `false`, **wstrzymaj** stream czytelny i **wznów** go na zdarzeniu `drain` writable. Ignorowanie zwracania `false` to klasyczny błąd backpressure.

## Ze asynchroniczną iteracją (nowoczesne, czyste)

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

## Preferuj pipeline dla bezpieczeństwa

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

## Dlaczego to ważne

Backpressure to subtelne, ale krytyczne pojęcie dla każdego usługi Node intensive data (przetwarzanie plików, proxy, streaming, ETL).

Ignorowanie go — poprzez buforowanie wszystkiego lub ignorowanie zwracanej wartości `write()` — powoduje nieograniczony wzrost pamięci i awarie pod obciążeniem, często tylko w produkcji z dużymi danymi.

Zrozumienie, że `pipe`/`pipeline` obsługują go automatycznie (główny powód, aby je preferować), i jak go respektować ręcznie (wstrzymanie na `false`, wznowienie na `drain`) lub poprzez `for await`, to co pozwala budować systemy streamingowe, które pozostają stabilne pod względem pamięci niezależnie od tego, jak duże lub szybkie są dane.

To cecha charakterystyczna kompetentnego użycia streamów.