streams లో backpressure అంటే ఏమిటి మరియు మీరు దానిని ఎలా నిర్వహిస్తారు?

Question

Accepted Answer

**Backpressure** ఏ డేటా ఉత్పత్తి చేయబడుతుందో **దానిని వినియోగించటం కంటే వేగంగా** ఉండినప్పుడు జరుగుతుంది. Streams లో, ఒక వేగవంతమైన readable source నెమ్మదిగా ఉన్న writable destination లోకి డేటాను నెట్టివేస్తే, వినియోగం చేయని డేటా మెమోరీ లో బఫర్ అవుతుంది — మరియు నిర్వహణ లేకుండా, ఆ బఫర్ మెమోరీ అయిపోయే వరకు పెరుగుతుంది. Backpressure అనేది producer మరియు consumer లను సమతుల్యం లో ఉంచే యంత్రం (మరియు క్రమశిక్షణ).

## సమస్య

```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 సేవ కోసం (ఫైల్ ప్రాసెసింగ్, ప్రాక్సీ చేయడం, streaming, ETL) ఒక సూక్ష్మమైన కానీ క్రిటికల్ కాన్సెప్ట్.

దానిని విస్మరించడం — ప్రతిదీ బఫర్ చేయడం లేదా `write()` యొక్క రిటర్న్ విలువను విస్మరించడం — అపరిమిత మెమోరీ పెరుగుదల మరియు లోడ్ కింద క్రాష్‌ల కారణమవుతుంది, తరచుగా వికాస సమయంలో బड్డ డేటా లేకుండా.

`pipe`/`pipeline` సాధారణంగా నిర్వహిస్తాయని అర్థం చేసుకోవడం (వాటిని ఆశ్రయించడానికి ప్రధాన కారణం), మరియు సాధారణంగా దానిని గౌరవించవలసిన విధానం (`false` పై పాజ్ చేయండి, `drain` పై పునరారంభించండి) లేదా `for await` ద్వారా, డేటా ఎంత పెద్దదైనా లేదా వేగవంతమైనా ఉన్నా మెమోరీ-స్థిరమైన సిస్టమ్‌ను రూపొందించడానికి మీకు అనుమతిస్తుంది.

ఇది సక్షమమైన stream వినియోగం యొక్క నిర్ణయ సంకేతం.