Ce este backpressure-ul în streams și cum îl gestionezi?

Question

Accepted Answer

**Backpressure-ul** este ceea ce se întâmplă atunci când datele sunt produse **mai repede decât pot fi consumate**. În streams, dacă o sursă readable rapidă împinge date într-o destinație writable lentă, datele neconsumate se acumulează în memorie — și fără gestionare, acest buffer crește până când memoria se epuizează. Backpressure-ul este mecanismul (și disciplina) pentru a menține producătorul și consumatorul în echilibru.

## Problema

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

Exemplu: citirea unui fișier imens rapid și scrierea lui pe un socket de rețea lent sau pe disc — dacă nu respecți ritmul destinației, memoria crește exponențial.

## pipe gestionează backpressure-ul automat

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

Acesta este un motiv major pentru a folosi `pipe`/`pipeline`: ei gestionează backpressure-ul pentru tine, întrerupând și reluând fluxul así încât memoria să rămână limitată indiferent de nepotrivirea de dimensiuni.

## Gestionarea manuală cu valoarea returnată de 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
  }
});
```

Dacă gestionezi streamurile manual, regula este: când `writable.write()` returnează `false`, **întrerupe** readable-ul și **reia**-l la evenimentul `drain` al writable-ului. Ignorarea returnării `false` este bug-ul clasic de backpressure.

## Cu iterație asincronă (modern, curat)

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

## Preferă pipeline pentru siguranță

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

## De ce este important

Backpressure-ul este un concept subtil dar critic pentru orice serviciu Node intensiv în date (procesare de fișiere, proxy, streaming, ETL).

Ignorarea lui — prin buffering a totului sau ignorarea valorii returnate de `write()` — provoacă creștere de memorie nelimitată și blocări sub sarcină, adesea doar în producție cu date mari.

Înțelegerea că `pipe`/`pipeline` îl gestionează automat (motivul principal pentru a-i prefera), și cum să-l respecți manual (întrerupe pe `false`, reia pe `drain`) sau prin `for await`, este ceea ce te permite să construiești sisteme de streaming care rămân stabile din punct de vedere al memoriei indiferent cât de mari sau rapide sunt datele.

Este o caracteristică definitorie a utilizării competente a stream-urilor.