Cos'è il backpressure nei stream e come lo gestisci?

Question

Accepted Answer

Il **backpressure** è quello che accade quando i dati vengono prodotti **più velocemente di quanto possano essere consumati**. Negli stream, se una sorgente leggibile veloce spinge dati in una destinazione scrivibile lenta, i dati non consumati si accumulano in memoria — e senza gestione, quel buffer cresce finché la memoria non si esaurisce. Il backpressure è il meccanismo (e la disciplina) per mantenere il produttore e il consumatore in equilibrio.

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

Esempio: leggere velocemente un file enorme e scriverlo in un socket di rete lento o su disco — se non rispetti il ritmo della destinazione, la memoria esplode.

## pipe gestisce il backpressure automaticamente

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

Questo è un motivo principale per usare `pipe`/`pipeline`: gestiscono il backpressure per te, mettendo in pausa e riprendendo il flusso in modo che la memoria rimanga limitata indipendentemente dalla mancata corrispondenza di dimensioni.

## Gestirlo manualmente con il valore di ritorno di 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
  }
});
```

Se gestisci gli stream manualmente, la regola è: quando `writable.write()` restituisce `false`, **metti in pausa** il leggibile, e **riprendi** al `drain` event dello scrivibile. Ignorare il ritorno di `false` è il classico bug di backpressure.

## Con async iteration (moderno, pulito)

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

## Preferisci pipeline per la sicurezza

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

## Perché è importante

Il backpressure è un concetto sottile ma critico per qualsiasi servizio Node con uso intensivo di dati (elaborazione file, proxying, streaming, ETL).

Ignorarlo — memorizzando tutto in buffer o ignorando il valore di ritorno di `write()` — causa una crescita illimitata della memoria e arresti anomali sotto carico, spesso solo in produzione con dati di grandi dimensioni.

Capire che `pipe`/`pipeline` lo gestiscono automaticamente (il motivo principale per preferirli), e come rispettarlo manualmente (pausa su `false`, riprendi su `drain`) o tramite `for await`, è quello che ti permette di costruire sistemi di streaming che rimangono stabili in memoria indipendentemente da quanto siano grandi o veloci i dati.

È un segno distintivo dell'uso competente degli stream.