Was ist Backpressure in Streams und wie geht man damit um?

Question

Accepted Answer

**Backpressure** ist das, was passiert, wenn Daten **schneller produziert werden, als sie verbraucht werden können**. Bei Streams geben schnelle lesbare Quellen Daten an langsame beschreibbare Ziele — die ungenutzten Daten werden im Speicher gepuffert, und ohne Behandlung wächst dieser Puffer, bis der Speicher erschöpft ist. Backpressure ist der Mechanismus (und die Disziplin), um Produzent und Konsument im Gleichgewicht zu halten.

## Das Problem

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

Beispiel: Schnelles Lesen einer riesigen Datei und Schreiben auf einen langsamen Netzwerk-Socket oder eine Festplatte — wenn Sie nicht das Tempo des Ziels respektieren, wächst der Speicher unkontrolliert.

## pipe behandelt Backpressure automatisch

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

Das ist ein Hauptgrund für die Verwendung von `pipe`/`pipeline`: Sie verwalten Backpressure für Sie und unterbrechen und setzen den Fluss fort, damit der Speicher unabhängig von Größenunterschieden begrenzt bleibt.

## Manuelle Behandlung mit dem Rückgabewert von 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
  }
});
```

Wenn Sie Streams manuell behandeln, lautet die Regel: Wenn `writable.write()` `false` zurückgibt, **unterbrechen** Sie die lesbare Quelle und **setzen** Sie sie bei dem `drain`-Event des beschreibbaren Ziels fort. Den `false`-Rückgabewert zu ignorieren ist der klassische Backpressure-Bug.

## Mit async iteration (modern, sauber)

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

## Bevorzugen Sie pipeline für Sicherheit

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

## Warum es wichtig ist

Backpressure ist ein subtiles, aber kritisches Konzept für jeden datenintensiven Node-Service (Dateiverarbeitung, Proxying, Streaming, ETL).

Es zu ignorieren — durch Pufferung von allem oder Ignorieren des Rückgabewerts von `write()` — führt zu unbegrenztem Speicherwachstum und Ausfällen unter Last, oft nur in der Produktivität mit großen Datenmengen.

Zu verstehen, dass `pipe`/`pipeline` dies automatisch behandelt (der Hauptgrund, sie zu bevorzugen), und wie man es manuell respektiert (`false` unterbrechen, `drain` fortsetzen) oder über `for await`, ermöglicht es Ihnen, Streamsysteme zu bauen, die speicherstabil bleiben, unabhängig davon, wie groß oder schnell die Daten sind.

Es ist ein Merkmal von kompetenter Stream-Nutzung.