Cad is backpressure i streams ann agus conas a bhainistítear é?

Question

Accepted Answer

**Backpressure** is an fhéachaint ar a tharlaíonn nuair a bhíonn sonraí á dtáirgeadh **níos tapúla ná is féidir a ithe**. I streams, má bhrunn foinse inléite thapa sonraí isteach i ndestination inrite mall, buffersaítear na sonraí nach raibh ite sa chuimhne — agus gan bhainistíonn, fásann an buffer go dtí go dtugtar deireadh don chuimhne. Is é backpressure an meicníonn (agus an disciplín) chun an táirgeoir agus an tomhaltóir a choinneáil i gcothromaíochta.

## An fhadhb

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

Sampla: comhad ollmhór á léamh go tapa agus á scríobh chuig soicéad nithiúil mall nó diosca — mura bhreathnaíonn tú ar phás an chinn scríobhtha, fásann an chuimhne.

## pipe a bhainistíonn backpressure go huachtar

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

Is é seo príomhchúis a úsáid `pipe`/`pipeline`: bainistíonn siad backpressure ar do shon, ag soicéad agus ag atosú an tsrutha ionas go bhfanann an chuimhne teoranta beag ar bith gan cibé acu méid neamhréithithe.

## A bhainistiú go láimhdeach le luach fillte 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
  }
});
```

Má bhainistíonn tú streams go láimhdeach, is é an riail ná: nuair a thugann `writable.write()` ar ais `false`, **soicéad** an inléite, agus **atosaigh** é ar an writable's `drain` imeall. Is é an fabht backpressure clasaiceach an `false` tuairim a sheachaint.

## Le async iteration (nua-aimseartha, geal)

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

## Labhair pipeline ar mhaithe le sábháilteacht

```js
import { pipeline } from "stream/promises";
await pipeline(source, transform, destination); // backpressure + error handling + cleanup
```

## Cad is fiú dó

Is é backpressure ná coincheap foluain ach ríthábhachtach d'aon seirbhís Node-bhunaithe ar dhátaoibh (próiseáil comhaid, fóntóireacht, sruthanna, ETL).

Ag teip air — trí rud ar fad a bhuffering nó ag fágáil neamhfhreagartha i gconair `write()` — is dócha go bhfásann an chuimhne gan teorainn agus go dtitfidh sé faoi ualach, go minic in seirbhís dhó le sonraí mór.

Tuigint go ndéanann `pipe`/`pipeline` é go huachtar (an phríomhchúis a bhímis ar an aghaidh orthu), agus conas a bhreathnaítear air go láimhdeach (soicéad ar `false`, atosaigh ar `drain`) nó trí `for await`, is ar an rud sin a ligeann duit sistéim sruthanna a thógáil a fhanann stabalta gan cibé acu chomh mór nó chomh tapa agus a bhíonn na sonraí.

Is é seo an marc a shainmhíníonn an úsáid níos oilte ar streams.