Wat is backpressure in streams en hoe handel je het af?

Question

Accepted Answer

**Backpressure** is wat gebeurt wanneer data **sneller wordt geproduceerd dan dat deze kan worden geconsumeerd**. In streams, als een snelle readable bron data naar een langzame writable bestemming pusht, buffert de ongebruikte data in het geheugen — en zonder afhandeling groeit die buffer totdat het geheugen uitgeput is. Backpressure is het mechanisme (en discipline) om producer en consumer in balans te houden.

## Het probleem

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

Voorbeeld: snel een enorm bestand lezen en het naar een langzame netwerksoket of schijf schrijven — als je het tempo van de bestemming niet respecteert, groeit het geheugen explosief.

## pipe handelt backpressure automatisch af

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

Dit is een belangrijke reden om `pipe`/`pipeline` te gebruiken: zij beheren backpressure voor je, pauzeren en hervatten de flow zodat het geheugen begrensd blijft, ongeacht de grootteverschil.

## Handmatige afhandeling met de returnwaarde van 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
  }
});
```

Als je streams handmatig afhandelt, is de regel: wanneer `writable.write()` `false` retourneert, **pauzeer** de readable, en **hervat** deze op het `drain` event van de writable. Het negeren van de `false` returnwaarde is de klassieke backpressure-bug.

## Met async iteratie (modern, schoon)

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

## Geef de voorkeur aan pipeline voor veiligheid

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

## Waarom het belangrijk is

Backpressure is een subtiel maar kritiek concept voor elke dataintensieve Node-service (bestandsverwerking, proxying, streaming, ETL).

Det negeren — door alles te bufferen of de returnwaarde van `write()` te negeren — veroorzaakt onbeperkte geheugengroei en crashes onder belasting, vaak alleen in productie met grote data.

Begrijpen dat `pipe`/`pipeline` het automatisch afhandelen (de hoofdreden om deze de voorkeur te geven), en hoe je het handmatig respecteert (pauzeer bij `false`, hervat bij `drain`) of via `for await`, is wat je in staat stelt om streaming-systemen te bouwen die geheugen-stabiel blijven, ongeacht hoe groot of snel de data is.

Het is een kenmerk van deskundig stream-gebruik.