Apa itu backpressure dalam streams dan bagaimana cara menanganinya?

Question

Accepted Answer

**Backpressure** adalah apa yang terjadi ketika data diproduksi **lebih cepat daripada dapat dikonsumsi**. Dalam streams, jika sumber yang dapat dibaca dengan cepat mendorong data ke tujuan yang dapat ditulis dengan lambat, data yang tidak dikonsumsi akan di-buffer di memori — dan tanpa penanganan, buffer tersebut tumbuh hingga memori habis. Backpressure adalah mekanisme (dan disiplin) untuk menjaga produsen dan konsumen tetap seimbang.

## Masalahnya

```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: membaca file besar dengan cepat dan menulisnya ke soket jaringan atau disk yang lambat — jika Anda tidak menghormati kecepatan tujuan, memori melonjak.

## pipe menangani backpressure secara 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"));
```

Ini adalah alasan utama menggunakan `pipe`/`pipeline`: mereka mengelola backpressure untuk Anda, menjeda dan melanjutkan aliran sehingga memori tetap terbatas terlepas dari ketidakcocokan ukuran.

## Menanganinya secara manual dengan nilai pengembalian 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
  }
});
```

Jika Anda menangani streams secara manual, aturannya adalah: ketika `writable.write()` mengembalikan `false`, **jeda** yang dapat dibaca, dan **lanjutkan** pada acara `drain` dari writable. Mengabaikan pengembalian `false` adalah bug backpressure klasik.

## Dengan async iteration (modern, bersih)

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

## Lebih suka pipeline untuk keamanan

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

## Mengapa ini penting

Backpressure adalah konsep halus namun kritis untuk layanan Node apa pun yang intensif data (pemrosesan file, proxying, streaming, ETL).

Mengabaikannya — dengan membuffer semuanya atau mengabaikan nilai pengembalian `write()` — menyebabkan pertumbuhan memori yang tidak terbatas dan crash di bawah beban, sering kali hanya dalam produksi dengan data besar.

Memahami bahwa `pipe`/`pipeline` menanganinya secara otomatis (alasan utama untuk memilihnya), dan cara menghormatinya secara manual (jeda pada `false`, lanjutkan pada `drain`) atau melalui `for await`, adalah apa yang memungkinkan Anda membangun sistem streaming yang tetap stabil dalam memori terlepas dari seberapa besar atau cepat datanya.

Ini adalah tanda penting dari penggunaan stream yang kompeten.