स्ट्रीम में बैकप्रेशर क्या है और आप इसे कैसे संभालते हैं?

Question

Accepted Answer

**बैकप्रेशर** वह है जो तब होता है जब डेटा **उससे अधिक तेजी से उत्पादित होता है जितनी जल्दी इसका उपभोग किया जा सकता है**। स्ट्रीम में, यदि एक तेज़ पठनीय स्रोत धीमे लिखने योग्य गंतव्य में डेटा धकेलता है, तो unconsumed डेटा मेमोरी में buffer होता है — और संभालने के बिना, वह buffer तब तक बढ़ता है जब तक कि मेमोरी समाप्त न हो जाए। बैकप्रेशर वह तंत्र (और अनुशासन) है जो उत्पादक और उपभोक्ता को संतुलन में रखता है।

## समस्या

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

उदाहरण: एक बहुत बड़ी फाइल को तेजी से पढ़ना और इसे एक धीमे नेटवर्क सॉकेट या डिस्क में लिखना — यदि आप गंतव्य की गति का सम्मान नहीं करते, तो मेमोरी बढ़ जाती है।

## pipe स्वचालित रूप से बैकप्रेशर को संभालता है

```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` का उपयोग करने का मुख्य कारण है: वे आपके लिए बैकप्रेशर को प्रबंधित करते हैं, flow को रोकते और फिर से शुरू करते हैं ताकि मेमोरी आकार mismatch के बावजूद bounded रहे।

## write() के return value के साथ इसे manually संभालना

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

यदि आप स्ट्रीम को manually संभालते हैं, तो नियम है: जब `writable.write()` `false` return करता है, **readable को pause करें**, और इसे writable के `drain` event पर **resume करें**। `false` return को ignore करना classic 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
```

## यह क्यों महत्वपूर्ण है

बैकप्रेशर किसी भी data-intensive Node service के लिए एक सूक्ष्म लेकिन महत्वपूर्ण अवधारणा है (फाइल प्रोसेसिंग, proxying, streaming, ETL)।

इसे ignore करना — सब कुछ buffer करके या `write()` के return value को ignore करके — unbounded memory growth और load के अंतर्गत crashes का कारण बनता है, अक्सर केवल production में बड़े डेटा के साथ।

यह समझना कि `pipe`/`pipeline` स्वचालित रूप से इसे handle करता है (उन्हें प्राथमिकता देने का मुख्य कारण), और इसे manually कैसे सम्मान करें (`false` पर pause, `drain` पर resume) या `for await` के माध्यम से, यह वह है जो आपको ऐसी streaming systems बनाने देता है जो भले ही डेटा कितना भी बड़ा या तेज़ हो, memory-stable रहती हैं।

यह stream usage की competence की एक defining mark है।