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

Question

IT Interview Practice · 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.

Het probleem

pipe handelt backpressure automatisch af

Handmatige afhandeling met de returnwaarde van write()

Met async iteratie (modern, schoon)

Geef de voorkeur aan pipeline voor veiligheid

Waarom het belangrijk is

Gerelateerde vragen