streams میں backpressure کیا ہے اور آپ اسے کیسے ہینڈل کرتے ہیں؟

Question

Accepted Answer

**Backpressure** وہ ہے جو اس وقت ہوتا ہے جب data **اس سے تیزی سے پیدا ہو جتنا اسے consume کیا جا سکتا ہے**۔ streams میں، اگر ایک تیز readable source ایک سست writable destination میں data دھکیلتا ہے، تو غیر consumed data memory میں buffer ہوتا ہے — اور handling کے بغیر، وہ buffer بڑھتا رہتا ہے جب تک memory ختم نہ ہو جائے۔ Backpressure producer اور consumer کو توازن میں رکھنے کا mechanism (اور نظم) ہے۔

## مسئلہ

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

مثال: ایک بڑی file کو تیزی سے پڑھنا اور اسے ایک سست network socket یا disk پر لکھنا — اگر آپ destination کی رفتار کا احترام نہیں کرتے، تو memory پھول جاتی ہے۔

## 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 manage کرتے ہیں، flow کو pause اور resume کرتے ہیں تاکہ size کے فرق سے قطع نظر memory bounded رہے۔

## write() کی return value کے ساتھ اسے دستی طور پر ہینڈل کرنا

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

اگر آپ streams کو دستی طور پر ہینڈل کرتے ہیں، تو اصول یہ ہے: جب `writable.write()` `false` return کرے، readable کو **pause** کریں، اور writable کے `drain` event پر اسے **resume** کریں۔ `false` return کو نظر انداز کرنا کلاسیکی backpressure bug ہے۔

## 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 کسی بھی data-intensive Node service (file processing، proxying، streaming، ETL) کے لیے ایک باریک مگر اہم تصور ہے۔

اسے نظر انداز کرنا — سب کچھ buffer کر کے یا `write()` کی return value کو نظر انداز کر کے — unbounded memory growth اور load کے تحت crashes کا سبب بنتا ہے، اکثر صرف production میں بڑے data کے ساتھ۔

یہ سمجھنا کہ `pipe`/`pipeline` اسے خودکار طور پر ہینڈل کرتے ہیں (انہیں ترجیح دینے کی بنیادی وجہ)، اور اسے دستی طور پر (`false` پر pause، `drain` پر resume) یا `for await` کے ذریعے کیسے احترام دینا ہے، وہ چیز ہے جو آپ کو ایسے streaming systems بنانے دیتی ہے جو memory-stable رہیں چاہے data کتنا ہی بڑا یا تیز کیوں نہ ہو۔

یہ قابلِ ستائش stream usage کی ایک نمایاں علامت ہے۔