Vad är backpressure i streams och hur hanterar du det?

Question

Accepted Answer

**Backpressure** är det som händer när data produceras **snabbare än den kan konsumeras**. I streams, om en snabb läskälla skickar data till ett långsamt skrivbara mål, buffras den okonsumerade datan i minnet — och utan hantering växer bufferten tills minnet är uttömt. Backpressure är mekanismen (och disciplinen) för att hålla producent och konsument i balans.

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

Exempel: läsa en stor fil snabbt och skriva den till en långsam nätverkssocket eller disk — om du inte respekterar destinationens tempo, växer minnet explosivt.

## pipe hanterar backpressure automatiskt

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

Detta är en stor anledning till att använda `pipe`/`pipeline`: de hanterar backpressure för dig, pausar och återupptar flödet så att minnet förblir begränsat oavsett storleksskillnad.

## Hantera det manuellt med write():s returvärde

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

Om du hanterar streams manuellt är regeln: när `writable.write()` returnerar `false`, **pausa** den läsbara, och **återuppta** den på skrivbara:s `drain`-event. Att ignorera `false`-returvärdet är klassiska backpressure-buggen.

## Med async iteration (modern, ren)

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

## Föredra pipeline för säkerhet

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

## Varför det spelar roll

Backpressure är ett subtilt men kritiskt koncept för alla dataintensiva Node-tjänster (filbehandling, proxying, streaming, ETL).

Att ignorera det — genom att buffra allt eller ignorera `write()`:s returvärde — orsakar obegränsad minnestillväxt och krascher under belastning, ofta bara i produktion med stora datamängder.

Att förstå att `pipe`/`pipeline` hanterar det automatiskt (huvudskälet till att föredra dem), och hur man respekterar det manuellt (pausa på `false`, återuppta på `drain`) eller via `for await`, är det som låter dig bygga streamingsystem som förblir minnesstabila oavsett hur stor eller snabb datan är.

Det är ett kännetecken på kompetent streamanvändning.