რა არის backpressure stream-ებში და როგორ უკეთებთ მას?

Question

Accepted Answer

**Backpressure** ის ის რაც ხდება როდესაც ინფორმაცია აწარმოებელია **უფრო სწრაფად ვიდრე შეიძლება მოხმარდეს**. Stream-ებში, თუ სწრაფი readable წყარო უბიძგებს მონაცემებს ნელი writable გამოსავალში, არამოხმარი მონაცემები buffer-დება მეხსიერებაში — და დამუშავების გარეშე, ეს buffer იზრდება სანამ მეხსიერება ამოწურული არ იქნება. 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
  }
});
```

თუ stream-ებს ხელით მართავთ, წესი არის: როდესაც `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).

მისი იგნორირება — ყველაფრის buffer-დებით ან `write()` დაბრუნების მნიშვნელობის იგნორირებით — იწვევს უსაზღვრო მეხსიერების ზრდას და სირთულეებს დატვირთვის ქვეშ, ხშირად მხოლოდ პროდაქშნში დიდი მონაცემების დროს.

ის რომ გესმოდათ რომ `pipe`/`pipeline` ავტომატურად უკეთებენ ამას (მთავარი მიზეზი მათი უპირატესობის), და როგორ ამის მკაცრი დაცვა ხელით (დაჩერება `false`-ზე, აღადგენა `drain`-ზე) ან `for await`-ის მეშვეობით, არის ის რაც გახდის შესაძლებელი streaming სისტემების აგებას რომლებიც მეხსიერების სტაბილური რჩებიან მიუხედავად რამდენი დიდი ან სწრაფი მონაცემებია.

ეს კომპეტენტური stream მოხმარების განმსაზღვრელი ნიშანი.