Mikä on backpressure virroissa ja miten sitä käsitellään?

Question

Accepted Answer

**Backpressure** on se, mitä tapahtuu, kun tietoja tuotetaan **nopeammin kuin niitä voidaan kuluttaa**. Virroissa, jos nopea lukulähde työntää tietoja hitaaseen kirjoitustavoitteeseen, kuluttamattomia tietoja puskuroidaan muistiin — ja ilman käsittelyä tämä puskuri kasvaa, kunnes muisti loppuu. Backpressure on mekanismi (ja käytäntö) tuottajan ja kuluttajan tasapainon säilyttämiseksi.

## Ongelma

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

Esimerkki: valtavan tiedoston nopeasta lukemisesta ja kirjoittamisesta hitaaseen verkkokytkinään tai levylle — jos et kunnioita kohteen vauhtia, muisti kasvaa hallitsemattomasti.

## pipe käsittelee backpressuren automaattisesti

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

Tämä on pääsyy `pipe`/`pipeline` käyttöön: ne hallinnoivat backpressuren puolestasi, keskeyttävät ja jatkavat virtaa niin, että muisti pysyy rajattuna koon epäsopivuudesta riippumatta.

## Manuaalinen käsittely write()-n paluuarvon avulla

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

Jos käsittelet virtoja manuaalisesti, sääntö on: kun `writable.write()` palauttaa `false`, **keskeytä** lukeminen ja **jatka** sitä kirjoitettavan `drain`-tapahtumassa. `false`-paluuarvon huomioimatta jättäminen on klassinen backpressure-virhe.

## Async iteration -iteraation kanssa (moderni, siisti)

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

## Suosi pipelinea turvallisuuden vuoksi

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

## Miksi sillä on merkitystä

Backpressure on hienovarainen mutta kriittinen käsite kaikille tietointensiivisille Node-palveluille (tiedostojen käsittely, välityspalvelin, streaming, ETL).

Sen huomioimatta jättäminen — kaiken puskuroimalla tai `write()`-n paluuarvon huomioimatta jättämällä — aiheuttaa rajoittamatonta muistin kasvua ja kaatumisia kuormitetulla, usein vain tuotannossa suurten tietojen kanssa.

Ymmärrys siitä, että `pipe`/`pipeline` käsittelevät sen automaattisesti (pääsyy niiden suosimiselle), ja kuinka kunnioittaa sitä manuaalisesti (keskeytä `false`-arvolla, jatka `drain`-arvolla) tai `for await` -iteraation kautta, on se, mikä antaa sinulle mahdollisuuden rakentaa virtausjärjestelmiä, jotka pysyvät muistin kannalta vakaaina riippumatta siitä, kuinka suuria tai nopeita tiedot ovat.

Se on tehokkaan virran käytön tunnusmerkki.