Backpressure trong streams là gì và xử lý nó như thế nào?

Question

Accepted Answer

**Backpressure** là điều xảy ra khi dữ liệu được tạo ra **nhanh hơn mức có thể tiêu thụ**. Trong streams, nếu một nguồn readable nhanh đẩy dữ liệu vào một đích writable chậm, dữ liệu chưa tiêu thụ tích vào bộ nhớ — và nếu không xử lý, buffer đó phình lên cho tới khi cạn bộ nhớ. Backpressure là cơ chế (và kỷ luật) để giữ cân bằng giữa nơi sản xuất và nơi tiêu thụ.

## Vấn đề

```text
Nguồn nhanh ──(1 GB/s)──▶ Đích chậm (tốc độ ghi 10 MB/s)
                          ▲
             Chênh lệch 990 MB/s chất vào buffer bộ nhớ → crash OOM
```

Ví dụ: đọc một file khổng lồ thật nhanh và ghi nó vào một socket mạng hoặc đĩa chậm — nếu bạn không tôn trọng nhịp của đích, bộ nhớ phình lên.

## pipe xử lý backpressure tự động

```js
import { createReadStream, createWriteStream } from "fs";

// ✅ pipe tự động tạm dừng nguồn khi đích đầy,
//    và tiếp tục khi đích rút cạn — backpressure được lo cho bạn
createReadStream("huge.file").pipe(createWriteStream("copy.file"));
```

Đây là lý do lớn để dùng `pipe`/`pipeline`: chúng quản lý backpressure cho bạn, tạm dừng và tiếp tục luồng để bộ nhớ giữ giới hạn bất kể chênh lệch kích thước.

## Xử lý thủ công bằng giá trị trả về của write()

```js
// write() trả về FALSE khi buffer nội bộ đầy — đó là tín hiệu backpressure
readable.on("data", (chunk) => {
  const ok = writable.write(chunk);
  if (!ok) {
    readable.pause();                       // ngừng đọc — đích đầy
    writable.once("drain", () => readable.resume()); // tiếp tục khi rút cạn
  }
});
```

Nếu bạn xử lý stream thủ công, quy tắc là: khi `writable.write()` trả về `false`, **tạm dừng** readable, và **tiếp tục** nó khi đích phát sự kiện `drain`. Bỏ qua giá trị trả về `false` là lỗi backpressure kinh điển.

## Với async iteration (hiện đại, sạch)

```js
// for-await tôn trọng backpressure tự nhiên — nó đợi xử lý từng chunk
for await (const chunk of readable) {
  await processSlowly(chunk); // chỉ kéo chunk kế tiếp khi sẵn sàng
}
```

## Ưu tiên pipeline cho an toàn

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + xử lý lỗi + dọn dẹp
```

## Tại sao điều này quan trọng

Backpressure là một khái niệm tinh tế nhưng then chốt cho bất kỳ service Node nặng dữ liệu nào (xử lý file, proxy, streaming, ETL).

Bỏ qua nó — bằng cách đệm hết hoặc bỏ qua giá trị trả về của `write()` — gây phình bộ nhớ vô hạn và crash dưới tải, thường chỉ trong production với dữ liệu lớn.

Hiểu rằng `pipe`/`pipeline` xử lý nó tự động (lý do chính để ưu tiên chúng), và cách tôn trọng nó thủ công (tạm dừng khi `false`, tiếp tục khi `drain`) hoặc qua `for await`, là điều giúp bạn xây các hệ thống streaming ổn định bộ nhớ bất kể dữ liệu lớn hay nhanh đến đâu.

Đó là dấu hiệu định danh việc dùng stream thành thạo.