streams मध्ये backpressure म्हणजे काय आणि तुम्ही त्याला कसे हाताळता?

Question

Accepted Answer

**Backpressure** हे असे घडते जेव्हा डेटा **वापरले जाऊ शकते त्यापेक्षा वेगाने तयार होता**. Streams मध्ये, जर एक जलद readable स्रोत डेटा एका मंद writable गंतव्यापर्यंत ढकलत असेल, तर वापरलेला डेटा मेमरीमध्ये बफर होतो — आणि हाताळणी केल्याशिवाय, तो बफर मेमरी संपेपर्यंत वाढतो. 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
```

उदाहरण: एक विशाल फाइल वेगाने वाचणे आणि त्याला मंद नेटवर्क सॉकेट किंवा डिस्कवर लिहणे — जर तुम्ही गंतव्यांचा गती मान्य केला तर मेमरी वाढते.

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

जर तुम्ही streams हाताळल्यास, नियम असा आहे: जेव्हा `writable.write()` `false` परत करते, तेव्हा readable ला **थांबवा**, आणि writable च्या `drain` इव्हेंटवर त्याला **पुन्हा सुरू करा**. `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 सेवेसाठी (फाइल प्रक्रिया, प्रॉक्सिइंग, स्ट्रीमिंग, ETL).

त्याकडे दुर्लक्ष करणे — सर्वकाही बफर करून किंवा `write()` च्या परताव्याकडे दुर्लक्ष करून — अमर्यादित मेमरी वृद्धी आणि लोडच्या अंतर्गत क्रॅश होते, बहुतेक वेळा फक्त उत्पादनमध्ये मोठ्या डेटासह.

हे समजणे की `pipe`/`pipeline` हे स्वयंचलितपणे हाताळतात (त्यांना पसंद करण्याचे मुख्य कारण), आणि हे कसे मॅन्युअलपणे सम्मान करावे (false वर थांबवा, drain वर पुन्हा सुरू करा) किंवा `for await` द्वारे, हे तुम्हाला स्ट्रीमिंग सिस्टम तयार करण्यास अनुमति देते जे डेटा किती मोठा किंवा वेगवान असो तरी मेमरी-स्थिर राहते.

हे प्रभावी stream वापराचे वैशिष्ट्य आहे.

समस्या

pipe स्वयंचलितपणे backpressure हाताळते

write() च्या परताव्याने हाताळणी करा

async iteration सह (आधुनिक, स्वच्छ)

सुरक्षिततेसाठी pipeline पसंद करा

हे महत्वाचे का आहे

`write()` च्या परताव्याने हाताळणी करा