Backpressure ใน stream คืออะไร และคุณจัดการมันอย่างไร?

Question

Accepted Answer

**Backpressure** คือสิ่งที่เกิดขึ้นเมื่อข้อมูลถูกผลิต **เร็วกว่าที่จะถูกบริโภคได้** ใน stream ถ้า readable source ที่เร็วผลักข้อมูลเข้าไปใน writable destination ที่ช้า ข้อมูลที่ยังไม่ถูกบริโภคจะ buffer อยู่ในหน่วยความจำ — และถ้าไม่จัดการ buffer นั้นจะโตขึ้นจนหน่วยความจำหมด Backpressure คือกลไก (และวินัย) สำหรับการรักษาสมดุลระหว่างผู้ผลิตและผู้บริโภค

## ปัญหา

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

ตัวอย่าง: การอ่านไฟล์ขนาดใหญ่อย่างรวดเร็วแล้วเขียนลง network socket หรือดิสก์ที่ช้า — ถ้าคุณไม่เคารพจังหวะของ destination หน่วยความจำจะพองตัว

## pipe จัดการ backpressure โดยอัตโนมัติ

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

นี่เป็นเหตุผลหลักในการใช้ `pipe`/`pipeline`: มันจัดการ backpressure ให้คุณ โดยหยุดและทำการไหลต่อเพื่อให้หน่วยความจำมีขอบเขตไม่ว่าขนาดจะต่างกันเพียงใด

## การจัดการด้วยตนเองด้วยค่าที่ 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
  }
});
```

ถ้าคุณจัดการ stream ด้วยตนเอง กฎคือ: เมื่อ `writable.write()` คืนค่า `false` ให้ **pause** readable และ **resume** มันเมื่อเกิด event `drain` ของ writable การละเลยค่า `false` ที่คืนมาคือบั๊ก backpressure คลาสสิก

## ด้วย async iteration (สมัยใหม่ สะอาด)

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

## เลือกใช้ pipeline เพื่อความปลอดภัย

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

## ทำไมจึงสำคัญ

Backpressure เป็นแนวคิดที่ละเอียดอ่อนแต่สำคัญสำหรับ Node service ใด ๆ ที่ใช้ข้อมูลหนัก (การประมวลผลไฟล์, การ proxy, การ streaming, ETL)

การละเลยมัน — โดยการ buffer ทุกอย่างหรือเพิกเฉยต่อค่าที่ `write()` คืนกลับ — ทำให้หน่วยความจำโตอย่างไร้ขอบเขตและ crash ภายใต้ภาระงาน ซึ่งมักเกิดเฉพาะใน production กับข้อมูลขนาดใหญ่

การเข้าใจว่า `pipe`/`pipeline` จัดการมันโดยอัตโนมัติ (เหตุผลหลักในการเลือกใช้) และวิธีเคารพมันด้วยตนเอง (pause เมื่อ `false`, resume เมื่อ `drain`) หรือผ่าน `for await` คือสิ่งที่ช่วยให้คุณสร้างระบบ streaming ที่หน่วยความจำเสถียรไม่ว่าข้อมูลจะใหญ่หรือเร็วเพียงใด

มันเป็นเครื่องหมายที่บ่งบอกถึงการใช้ stream อย่างเชี่ยวชาญ