Kaj je povratni pritisk (backpressure) v tokovih in kako ga obravnaviš?

Question

Accepted Answer

**Povratni pritisk (backpressure)** se zgodi, ko se podatki proizvajajo **hitreje, kot jih je mogoče porabiti**. V tokovih, če hitr vir berljivih podatkov potiska podatke v počasno destinacijo za pisanje, se neporabljeni podatki nabirajo v pomnilniku — in brez obravnavanja se ta medpomnilnik povečuje, dokler se pomnilnik ne izcrpa. Povratni pritisk je mehanizem (in disciplina) za ohranjanje ravnotežja med proizvajalcem in potrošnikom.

## Težava

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

Primer: branje velike datoteke hitro in pisanje v počasen omrežni vtič ali disk — če ne spoštuješ tempa destinacije, se pomnilnik nenadzorovan povečuje.

## pipe obravnava povratni pritisk samodejno

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

To je glavni razlog za uporabo `pipe`/`pipeline`: upravljata povratni pritisk za teboj, zaustavita in nadaljujeta tok, da pomnilnik ostane omejen ne glede na neskladje v velikosti.

## Ročna obravnava z vrnitveno vrednostjo 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
  }
});
```

Če ročno obravnaviš tokove, je pravilo: ko `writable.write()` vrne `false`, **zaustavi** berljivo stran in **nadaljuj** pri `drain` dogodku zapisljive strani. Ignoriranje vrnitve `false` je klasična napaka s povratnim pritiskom.

## Z asinkrono iteracijo (sodoben, čist pristop)

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

## Prednostno uporabi pipeline za varnost

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

## Zakaj je to pomembno

Povratni pritisk je subtilen, vendar kritičen koncept za vse podatkovne intenzivne Node storitve (obdelava datotek, proxy, pretakanje, ETL).

Ignoriranje — s hranjanjem vsega ali ignoriranjem vrnjene vrednosti `write()` — povzroča neomejeno rast pomnilnika in zrušitve ob obremenitvi, pogosto le v produkciji z velikimi podatki.

Razumevanje, da `pipe`/`pipeline` samodejno obravnavata povratni pritisk (glavni razlog, da ju prednostno uporabiš), in kako ga spoštovati ročno (zaustavi na `false`, nadaljuj pri `drain`) ali prek `for await`, je ključno za izgradnjo sistemov pretakanja, ki ostanejo stabilni po pomnilniku ne glede na velikost ali hitrost podatkov.

To je značilnost usposobljene uporabe tokov.