Streams-இல் backpressure என்றால் என்ன, அதை எப்படிக் கையாள்வீர்கள்?

Question

Accepted Answer

**Backpressure** என்பது data **நுகரப்படுவதைவிட வேகமாக** உற்பத்தி செய்யப்படும்போது நிகழ்வது. streams-இல், ஒரு வேகமான readable source ஒரு மெதுவான writable destination-க்கு data-ஐத் தள்ளினால், நுகரப்படாத data memory-இல் buffer ஆகிறது — மேலும் கையாளாமல், அந்த 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-ஐ நிர்வகிக்கின்றன, ஓட்டத்தை pause மற்றும் resume செய்து, அளவு பொருந்தாமை இருந்தாலும் 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-ஐ புறக்கணிப்பதன் மூலம் — load-இன் கீழ் unbounded memory வளர்ச்சியையும் crashes-ஐயும் ஏற்படுத்துகிறது, பெரும்பாலும் பெரிய data உடன் production-இல் மட்டுமே.

`pipe`/`pipeline` அதை தானாகக் கையாளுகின்றன என்பதை (அவற்றை விரும்புவதற்கான முக்கிய காரணம்), மற்றும் அதை கைமுறையாக எப்படி மதிப்பது (`false`-இல் pause, `drain`-இல் resume) அல்லது `for await` மூலம் என்பதைப் புரிந்துகொள்வது தான், data எவ்வளவு பெரியதாக அல்லது வேகமாக இருந்தாலும் memory-stable ஆக இருக்கும் streaming systems-ஐ உருவாக்க உங்களை அனுமதிக்கிறது.

இது திறமையான stream பயன்பாட்டின் ஒரு வரையறுக்கும் அடையாளம்.