Mi az a backpressure az adatfolyamokban és hogyan kezelik?

Question

Accepted Answer

A **backpressure** az, ami akkor történik, amikor az adatokat **gyorsabban állítják elő, mint ahogy azokat fel lehet dolgozni**. Az adatfolyamokban, ha egy gyors olvasható forrás adatokat tol egy lassú írható célhelyre, a fel nem dolgozott adatok memóriába kerülnek — és kezelés nélkül a puffer addig nő, amíg a memória ki nem merül. A backpressure a termelő és a fogyasztó egyensúlyban tartásának mechanizmusa (és fegyelme).

## A probléma

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

Példa: egy hatalmas fájl gyors olvasása és egy lassú hálózati szóketra vagy lemezre való írása — ha nem tisztelik a cél sebességét, a memória felduzzad.

## A pipe automatikusan kezeli a backpressure-t

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

Ez az a fő oka, hogy miért érdemes `pipe`/`pipeline`-t használni: a backpressure-t kezelik helyettünk, szüneteltik és folytatják az adatfolyamot, így a memória a méretbeli eltérés ellenére is korlátozott marad.

## Kézi kezelés a write() visszatérési értékével

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

Ha manuálisan kezeled az adatfolyamokat, a szabály: amikor a `writable.write()` `false`-t ad vissza, **szüneteltesd** az olvashatót, és **folytatsd** azt a írható `drain` eseményen. A `false` visszatérési érték figyelmen kívül hagyása a klasszikus backpressure hiba.

## Az aszinkron iterációval (modern, tiszta)

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

## Preferáld a pipeline-t a biztonság kedvéért

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

## Miért fontos

A backpressure egy finom, de kritikus fogalom bármilyen adatintenzív Node szolgáltatáshoz (fájlfeldolgozás, proxy, streaming, ETL).

Ennek figyelmen kívül hagyása — mindennek pufferelésével vagy a `write()` visszatérési értékének figyelmen kívül hagyásával — korlátlan memóriánövekedéshez és összeomláshoz vezet terhelés alatt, gyakran csak éles közegben nagy mennyiségű adat mellett.

Annak megértése, hogy a `pipe`/`pipeline` automatikusan kezeli (a fő oka annak, hogy miért érdemes inkább őket használni), és hogyan lehet manuálisan tiszteletben tartani (`false` esetén szüneteltetni, `drain` esetén folytatni) vagy az `for await` segítségével, az, ami lehetővé teszi, hogy olyan adatfolyam-rendszereket építs, amelyek memória szempontjából stabilak maradnak, függetlenül attól, hogy az adatok mennyire nagyok vagy gyorsak.

Ez a szakszerű adatfolyam-használat meghatározó jele.