Apakah itu backpressure dalam streams dan bagaimanakah anda mengendalikannya?

Question

Accepted Answer

**Backpressure** ialah apa yang berlaku apabila data dihasilkan **lebih pantas daripada ia boleh digunakan**. Dalam streams, jika sumber readable yang pantas menolak data ke dalam destinasi writable yang perlahan, data yang tidak digunakan menampan (buffer) dalam memori — dan tanpa pengendalian, buffer itu membesar sehingga memori kehabisan. Backpressure ialah mekanisme (dan disiplin) untuk mengekalkan keseimbangan antara penghasil dan pengguna.

## 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 fail yang sangat besar dengan pantas dan menulisnya ke soket rangkaian atau cakera yang perlahan — jika anda tidak menghormati kadar destinasi, memori membengkak.

## pipe mengendalikan backpressure secara automatik

```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 ialah sebab utama untuk menggunakan `pipe`/`pipeline`: ia menguruskan backpressure untuk anda, menjeda dan menyambung semula aliran supaya memori kekal terhad tanpa mengira ketidakpadanan saiz.

## Mengendalikannya secara manual dengan nilai pulangan 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 mengendalikan streams secara manual, peraturannya ialah: apabila `writable.write()` memulangkan `false`, **jeda** readable, dan **sambung semula** ia pada event `drain` writable. Mengabaikan pulangan `false` ialah pepijat backpressure klasik.

## Dengan lelaran async (moden, kemas)

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

## Utamakan pipeline untuk keselamatan

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

## Mengapa ia penting

Backpressure ialah konsep yang halus tetapi kritikal untuk sebarang perkhidmatan Node intensif data (pemprosesan fail, proksi, streaming, ETL).

Mengabaikannya — dengan menampan semuanya atau mengabaikan nilai pulangan `write()` — menyebabkan pertumbuhan memori tanpa had dan kemalangan di bawah beban, selalunya hanya dalam pengeluaran dengan data besar.

Memahami bahawa `pipe`/`pipeline` mengendalikannya secara automatik (sebab utama untuk mengutamakannya), dan cara menghormatinya secara manual (jeda pada `false`, sambung semula pada `drain`) atau melalui `for await`, ialah yang membolehkan anda membina sistem streaming yang kekal stabil dari segi memori tidak kira sebesar atau sepantas mana data itu.

Ia ialah tanda penentu penggunaan stream yang cekap.