Hva er backpressure i strømmer og hvordan håndterer du det?

Question

Accepted Answer

**Backpressure** er det som skjer når data produseres **raskere enn det kan konsumeres**. I strømmer, hvis en rask lesekilde presser data inn i en langsom skrivdestinasjon, blir uforbruke data bufret i minne — og uten håndtering vokser bufferen til minnet er oppbrukt. Backpressure er mekanismen (og disiplinen) for å holde produsent og konsument i balanse.

## 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: å lese en enorm fil raskt og skrive den til en langsom nettverkssokkel eller disk — hvis du ikke respekterer destinasjonens tempo, vokser minnet.

## 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 hovedgrunn til å bruke `pipe`/`pipeline`: de administrerer backpressure for deg, pauser og gjenopptar flyten slik at minnet forblir begrenset uavhengig av størrelsesmismatch.

## Håndter det manuelt med write()-returnverdien

```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 strømmer manuelt, er regelen: når `writable.write()` returnerer `false`, **pause** den lesbare strømmen, og **gjenoppta** den på skrivstrømmens `drain`-event. Å ignorere `false`-returnverdien er den klassiske backpressure-feilen.

## Med asynk iterasjon (moderne, ryddig)

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

## Foretrekk pipeline for sikkerhet

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

## Hvorfor det er viktig

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

Å ignorere det — ved å bufre alt eller ignorere `write()`-returnverdien — forårsaker ubegrenset minnevekst og krasj under belastning, ofte bare i produksjon med store data.

Å forstå at `pipe`/`pipeline` håndterer det automatisk (hovedgrunnen til å foretrekke dem), og hvordan du respekterer det manuelt (pause på `false`, gjenoppta på `drain`) eller via `for await`, er det som lar deg bygge strømsystemer som forblir minnestabile uavhengig av hvor stor eller rask dataen er.

Det er et kjennetegn på kompetent strømbruk.