Hvad er backpressure i streams og hvordan håndterer du det?

Question

Accepted Answer

**Backpressure** er det, der sker, når data produceres **hurtigere end de kan forbruges**. I streams, hvis en hurtig læsekilde skubber data ind i en langsom skrivekilde, bufres de forbrugte data i hukommelsen — og uden håndtering vil den buffer vokse, indtil hukommelsen er opbrugt. Backpressure er mekanismen (og disciplinen) for at holde producent og forbruger i balance.

## Problemet

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

Eksempel: Læsning af en enorm fil hurtigt og skrivning til en langsom netværks socket eller disk — hvis du ikke respekterer destinationens hastighed, sprænger hukommelsen.

## pipe håndterer backpressure automatisk

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

Dette er en hovedgrund til at bruge `pipe`/`pipeline`: de styrer backpressure for dig, pauser og genoptager flowet, så hukommelsen forbliver afgrænset uanset størrelsesmismatch.

## Håndtering af det manuelt med write()-ens returværdi

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

Hvis du håndterer streams manuelt, er reglen: når `writable.write()` returnerer `false`, **pause** læsningen, og **genoptag** den på writables `drain`-event. At ignorere `false`-returværdien er den klassiske backpressure-fejl.

## Med async iteration (moderne, rent)

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

## Foretrække pipeline for sikkerhed

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

## Hvorfor det betyder noget

Backpressure er et subtilt men kritisk koncept for enhver dataintensiv Node-service (filbehandling, proxying, streaming, ETL).

At ignorere det — ved at buffere alt eller ignorere `write()`-ens returværdi — forårsager ubegrænset hukommelsesvækst og nedbrud under belastning, ofte kun i produktion med store data.

At forstå, at `pipe`/`pipeline` håndterer det automatisk (hovedgrundenfor at foretrække dem), og hvordan man respekterer det manuelt (pause på `false`, genoptagelse på `drain`) eller via `for await`, er det, der gør dig i stand til at bygge streamsystemer, der forbliver hukommelsestabile uanset hvor store eller hurtige dataene er.

Det er et afgørende kendetegn ved kompetent streamanvendelse.