Kas yra atgalinis slėgis (backpressure) srautuose ir kaip jį valdyti?

Question

Accepted Answer

**Atgalinis slėgis** yra tai, kas atsitinka, kai duomenys yra gamybinami **greičiau nei jie gali būti suvartoti**. Srautuose, jei greitas skaitomas šaltinis išstumia duomenis į lėtą rašomą tikslą, nesuvartotas duomenys kaupunasi atmintyje — ir be tinkamo valdymo, tas buferis auga, kol atmintis išsisėda. Atgalinis slėgis yra mechanizmas (ir drausmė) gamintojui ir vartotojui išlaikyti pusiausvyroje.

## Problema

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

Pavyzdys: greitai skaitant didžiulį failą ir rašant jį į lėtą tinklo lizdą arba diską — jei neatitiksite paskirties tempo, atmintis kaip balionas išsipūsdina.

## pipe automatiškai tvarko atgalinį slėgį

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

Tai pagrindinis `pipe`/`pipeline` naudojimo tikslas: jie automatiškai tvarko atgalinį slėgį, sustabdydami ir vėl pradedami srautą, kad atmintis liktu ribota, nepaisant dydžio nesutapimo.

## Neautomatiško valdymo naudojant write() grąžintą reikšmę

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

Jei valdomate srautus neautomatiškai, taisyklė tokia: kai `writable.write()` grąžina `false`, **sustabdykite** skaitymą, ir **atnaujinkite** jį rašymo `drain` įvykyje. Ignoruojant `false` grąžą — tai klasikinis atgalinio slėgio klaida.

## Su asinchronine iteracija (šiuolaikiska, švari)

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

## Norėkite pipeline dėl saugumo

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

## Kodėl tai svarbu

Atgalinis slėgis yra subtilus, bet kritiškas koncepts bet kuriai duomenų apimčiai intensyviai Node paslaugai (failų apdorojimas, tarpininkavimas, srautinis perdavimas, ETL).

Jį ignoravus — visus duomenis kaupiant arba nekreipiant dėmesio į `write()` grąžintą reikšmę — atsiranda neribota atminties augimas ir strimai esant apkrovai, dažnai tik produkcijoje su dideliais duomenimis.

Supratimas, kad `pipe`/`pipeline` jį tvarko automatiškai (pagrindinis pagrindas jiems teikti pirmenybę), ir kaip jį respektuoti neautomatiškai (sustabdykite ties `false`, atnaujinkite ties `drain`) arba per `for await`, yra tai, kas leidžia jums kurti srautinius sistemas, kurios išliko atmintiniu stabilios, neatsižvelgiant į tai, kiek dideli ar greitai duomenys yra.

Tai yra kompetentingo srauto naudojimo ženklas.