Çfarë është backpressure në streams dhe si e menaxhoni atë?

Question

Accepted Answer

**Backpressure** është ajo që ndodh kur të dhënat prodhohen **më shpejt sesa mund të konsumohen**. Në streams, nëse një burim i lexueshëm i shpejtë shtyn të dhëna në një destinacion të ngadaltë për të shkruar, të dhënat e pakonsumuar balohen në memorie — dhe pa menaxhim, ajo buffer rritet derisa memoria të shterohej. Backpressure është mekanizmi (dhe disiplina) për të mbajtur producerin dhe konsumerin në balancë.

## Problemi

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

Shembull: leximi i një skedari obez shpejt dhe shkrim i tij në një soket rrjeti të ngadaltë ose disk — nëse nuk respektoni ritmin e destinacionit, memoria zmadhohet.

## pipe menaxhon backpressure automatikisht

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

Kjo është arsye kryesore për të përdorur `pipe`/`pipeline`: ata menaxhojnë backpressure për ju, duke pushuar dhe rimarrë rrjedhën në mënyrë që memoria të mbetet e kufizuar pavarësisht nga mospërputhja e madhësisë.

## Menaxhimi i tij manualisht me vlerën e kthimit të 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
  }
});
```

Nëse menaxhoni streams manualisht, rregulli është: kur `writable.write()` kthen `false`, **pushoni** lexuesit, dhe **rifillojeni** atë në ngjarjen `drain` të writable. Injoruese e kthimit `false` është bug-u klasik i backpressure.

## Me async iteration (modern, i pastër)

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

## Preferohet pipeline për sigurinë

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

## Pse ka rëndësi

Backpressure është një koncept delikat por kritik për çdo shërbim Node-i me kërkesa të mëdha për të dhëna (përpunim skedarësh, proxy, streaming, ETL).

Injoruese e tij — me buffering të gjithçkaje ose injoruese e vlerës kthyese të `write()` — shkakton rritje memoria e pakufizuar dhe dështime nën ngarkesë, shpesh vetëm në prodhim me të dhëna të mëdha.

Përvetësimi se `pipe`/`pipeline` e menaxhojnë atë automatikisht (arsyeja kryesore për t'i preferuar ato), dhe si ta respektoni atë manualisht (pushim në `false`, rifillim në `drain`) ose përmes `for await`, është ajo që ju lejon të ndërtoni sisteme streaming që mbeten të qëndrueshme në memorie pavarësisht se sa të mëdha ose të shpejtë janë të dhënat.

Isht një shenjë përcaktuese e përdorimit kompetent të stream.