Apa iku backpressure ing streams lan carane nangani?

Question

Accepted Answer

**Backpressure** yaiku apa sing kelakon nalika data diproduksi **luwih cepet tinimbang bisa dikonsumsi**. Ing streams, menawa sumber readable sing cepet metu data menyang destinasi writable sing alon, data sing durung dikonsumsi bakal buffer ing memory — lan tanpa nangani, buffer kasebut bakal tumbuh nganti memory abis. Backpressure yaiku mekanisme (lan disiplin) kanggo njaga producer lan consumer tetep seimbang.

## Masalah kasebut

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

Contoh: maca file gedhe cepet lan nulis ing socket jaringan alon utawa disk — yen sampeyan ora ngrungokake kecepatan destinasi, memory bakal membengkak.

## pipe nangani backpressure kanthi otomatis

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

Iki sebab utama nggunakake `pipe`/`pipeline`: dheweke ngatur backpressure kanggo sampeyan, ngremet lan nyambung malih aliran supaya memory tetep terbatas tanpa peduli ukuran ketidaksesuaian.

## Nangani kanthi manual nggunakake return value 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
  }
});
```

Yen sampeyan nangani streams kanthi manual, aturane: nalika `writable.write()` bali `false`, **wentinake** readable, lan **nyambung malih** ing event `drain` writable. Nglirwakake return `false` yaiku bug backpressure klasik.

## Kanthi async iteration (modern, resik)

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

## Luwih apik nggunakake pipeline kanggo kaluwihan

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

## Mengapa iki penting

Backpressure yaiku konsep sing halus nanging kritis kanggo layanan Node sing intensif data (pemrosesan file, proxying, streaming, ETL).

Nglirwakake — kanthi buffering kabeh-kabehe utawa nglirwakake return value `write()` — nyebabake pertumbuhan memory sing tanpa wates lan ambruk ing beban, asring mung ing produksi kanthi data gedhe.

Mengerti yen `pipe`/`pipeline` nangani kanthi otomatis (alasan utama kanggo luwih apik), lan carane ngrungokake kanthi manual (wentinake ing `false`, nyambung malih ing `drain`) utawa via `for await`, yaiku apa sing ndadekake sampeyan bisa mbangun sistem streaming sing tetep stabil memory tanpa peduli akimawa gedhe utawa cepet data kasebut.

Iki tandha anggaran penggunaan stream sing kompeten.