ਸਟ੍ਰੀਮ ਵਿੱਚ ਬੈਕਪ੍ਰੈਸ਼ਰ ਕੀ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ?

Question

Accepted Answer

**ਬੈਕਪ੍ਰੈਸ਼ਰ** ਉਹ ਹਾਲ ਹੈ ਜਦੋਂ ਡੇਟਾ **ਜਿਵੇਂ ਖਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਉਸ ਤੋਂ ਤੇਜ਼ ਰਫ਼ਤਾਰ ਨਾਲ** ਪੈਦਾ ਹੁੰਦਾ ਹੈ। ਸਟ੍ਰੀਮ ਵਿੱਚ, ਜੇ ਤੇਜ਼ readable ਸਰੋਤ ਹਲਕੇ writable ਮੰਜ਼ਿਲ ਵਿੱਚ ਡੇਟਾ ਭੇਜਦਾ ਹੈ, ਤਾਂ ਬਿਨਾਂ ਖਪਤ ਵਾਲਾ ਡੇਟਾ ਮੈਮੋਰੀ ਵਿੱਚ ਬਫ਼ਰ ਹੋ ਜਾਂਦਾ ਹੈ — ਅਤੇ ਬਿਨਾਂ ਸੰਭਾਲ ਦੇ, ਉਹ ਬਫ਼ਰ ਉਦੋਂ ਤੱਕ ਵਧਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਮੈਮੋਰੀ ਖਤਮ ਨਹੀਂ ਹੋ ਜਾਂਦੀ। ਬੈਕਪ੍ਰੈਸ਼ਰ ਉਹ ਵਿਧੀ (ਅਤੇ ਅਨੁਸ਼ਾਸਨ) ਹੈ ਜੋ 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
```

ਉਦਾਹਰਨ: ਇੱਕ ਵੱਡੀ ਫਾਈਲ ਨੂੰ ਤੇਜ਼ ਰਫ਼ਤਾਰ ਨਾਲ ਪੜ੍ਹਨਾ ਅਤੇ ਇਸ ਨੂੰ ਹਲਕੇ ਨੈੱਟਵਰਕ socket ਜਾਂ ਡਿਸਕ ਵਿੱਚ ਲਿਖਣਾ — ਜੇ ਤੁਸੀਂ ਮੰਜ਼ਿਲ ਦੀ ਰਫ਼ਤਾਰ ਦਾ ਸਨਮਾਨ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਮੈਮੋਰੀ ਵਿੱਚ ਵਾਧਾ ਹੋ ਜਾਂਦਾ ਹੈ।

## 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` ਦੀ ਵਰਤੋਂ ਦਾ ਇੱਕ ਪ੍ਰਮੁੱਖ ਕਾਰਣ ਹੈ: ਉਹ ਤੁਹਾਡੇ ਲਈ ਬੈਕਪ੍ਰੈਸ਼ਰ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਦੇ ਹਨ, ਪ੍ਰਵਾਹ ਨੂੰ ਰੋਕ ਅਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ ਤਾਂ ਮੈਮੋਰੀ ਸੀਮਾਬੱਧ ਰਹੇ, ਭਾਵੇਂ ਆਕਾਰ ਵਿੱਚ ਅੰਤਰ ਕਿਸੇ ਵੀ ਕਦਰ ਦਾ ਹੋ।

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

ਜੇ ਤੁਸੀਂ ਸਟ੍ਰੀਮ ਨੂੰ ਆਪਣੇ ਆਪ ਸੰਭਾਲਦੇ ਹੋ, ਤਾਂ ਨਿਯਮ ਹੈ: ਜਦੋਂ `writable.write()` `false` ਵਾਪਸ ਕਰਦਾ ਹੈ, **readable ਨੂੰ ਰੋਕੋ**, ਅਤੇ writable ਦੀ `drain` event ਉੱਤੇ **ਮੁੜ ਸ਼ੁਰੂ ਕਰੋ**। `false` return ਨੂੰ ਅਲੱਗ ਰੱਖਣਾ ਕਲਾਸਿਕ ਬੈਕਪ੍ਰੈਸ਼ਰ ਤ੍ਰੁਟੀ ਹੈ।

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

## ਇਸ ਦਾ ਮਾਤਰ

ਬੈਕਪ੍ਰੈਸ਼ਰ ਕਿਸੇ ਵੀ ਡੇਟਾ-ਗਹੀਰ Node service ਲਈ ਇੱਕ ਸੂਖਮ ਪਰ ਮਹੱਤਵਪੂਰਨ ਧਾਰਨਾ ਹੈ (ਫਾਈਲ ਪ੍ਰਾਸੈਸਿੰਗ, proxying, streaming, ETL)।
erenceIndex ਨੂੰ ਅਲੱਗ ਰੱਖਣਾ — ਸਭ ਕੁਝ ਬਫ਼ਰ ਕਰਕੇ ਜਾਂ `write()` ਦੀ return value ਨੂੰ ਅਲੱਗ ਰੱਖਕੇ — ਬੇਸੀਮਾ ਮੈਮੋਰੀ ਵਿਕਾਸ ਅਤੇ ਲੋਡ ਹੇਠ ਕ੍ਰੈਸ਼ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ, ਅਕਸਰ ਵੱਡੇ ਡੇਟਾ ਨਾਲ ਸਿਰਫ ਉਤਪਾਦਨ ਵਿੱਚ।

ਇਹ ਸਮਝਣਾ ਕਿ `pipe`/`pipeline` ਆਪਣੇ ਆਪ ਇਸ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ (ਉਹਨਾਂ ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਦਾ ਮੁੱਖ ਕਾਰਣ), ਅਤੇ ਇਸ ਨੂੰ ਆਪਣੇ ਆਪ ਕਿਵੇਂ ਸਨਮਾਨ ਕਰਨਾ ਹੈ (`false` ਉੱਤੇ ਰੋਕਨਾ, `drain` ਉੱਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨਾ) ਜਾਂ `for await` ਦੇ ਜ਼ਰੀਏ, ਉਹੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ streaming systems ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ ਜੋ ਭਾਵੇਂ ਡੇਟਾ ਕਿਸੀ ਵੀ ਆਕਾਰ ਜਾਂ ਰਫ਼ਤਾਰ ਦਾ ਹੋ, ਮੈਮੋਰੀ-ਸਥਿਰ ਰਹੇ।

ਇਹ ਕੁਸ਼ਲ stream ਵਰਤੋਂ ਦਾ ਇੱਕ ਪਰਿਭਾਸ਼ਿਤ ਨਿਸ਼ਾਨ ਹੈ।