როგორ აღმოაჩენთ და აასწორებთ მეხსიერების გაჟონვას Node.js-ში?

Question

Accepted Answer

**მეხსიერების გაჟონვა** არის მეხსიერება, რომელიც აღარ არის საჭირო, მაგრამ არასოდეს ხორციელდება, რადგან რაც-რამე მაინც მოიხსენიებს მას. დროთა განმავლობაში პროცესის heap იზრდება სანამ ის ნელი არ გახდება ან რამ ჩამოვარდეს (მეხსიერების ნაკლებობა). გრძელი ხნის განმავლობაში აღმოცენებული Node სერვერებისთვის გაჟონვა სერიოზული საწარმო პრობლემა არის.

## გაჟონვის საერთო წყაროები

```js
// 1. Unbounded caches / global collections that only grow
const cache = new Map();
app.get("/:id", (req, res) => { cache.set(req.params.id, data); }); // never cleared → grows forever

// 2. Forgotten event listeners (added repeatedly, never removed)
emitter.on("data", handler); // if added per-request and never removed → accumulates

// 3. Forgotten timers
setInterval(() => {...}, 1000); // never cleared, holds references alive

// 4. Closures capturing large objects longer than needed
function outer() {
  const huge = loadBigData();
  return () => huge.length; // keeps `huge` alive as long as the closure lives
}
```

საერთო ნაკი: ხელმისაწვდომი ბმული (გლობალური Map, ცოცხალი ქსელის ელემენტი, ნაკადი ტაიმერი, closure) თავს უფრთხებს ობიექტებს garbage collection-ისგან, მაშინაც კი თუ ისინი აღარ არის სასარგებლო.

## გაჟონვის აღმოჩენა

```js
// 1. Watch heap growth over time — steady upward trend = likely leak
setInterval(() => {
  const { heapUsed } = process.memoryUsage();
  console.log(`heap: ${(heapUsed / 1e6).toFixed(1)} MB`);
}, 10000);
```

```bash
# 2. Heap snapshots — capture at two points, compare what grew
node --inspect app.js     # then use Chrome DevTools → Memory → heap snapshots
# or the heapdump / clinic.js tools
```

დიაგნოსტიკური პროცესი: დაადასტურეთ, რომ heap თანმიმდევრობით იზრდება (არა მხოლოდ ნორმალური რყევა), შემდეგ აიღეთ **heap snapshots** საქმის დაწყებამდე და შემდეგ და შედარეთ, რომ იპოვოთ რომელი ობიექტის ტიპები რკო თვენილებული უნდა იყო ("retained size" იზრდება).

## გაჟონვის გამოსწორება

```js
// ✅ bound caches with TTL/size limits (LRU)
import { LRUCache } from "lru-cache";
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 }); // evicts automatically

// ✅ always remove listeners and clear timers
emitter.off("data", handler);
clearInterval(timer);

// ✅ use WeakMap/WeakSet for metadata that shouldn't keep objects alive
const meta = new WeakMap(); // entries are GC'd when the key object is
```

შესწორებები ასახელებს მიზეზებს: შეზღუდული caches (LRU თან მაქსიმალური ზომა/TTL), ყოველთვის დააკავშირეთ listener/timer შექმნა დასუფთავებით და გამოიყენეთ `WeakMap`/`WeakSet` ობიექტის გასაღები მეტამონაცემისთვის, რომელიც არ უნდა ჩაკეტოს ობიექტები მეხსიერებაში.

## რატომ არის ეს მნიშვნელოვანი

მეხსიერების გაჟონვა განსაკუთრებით საშიშია Node-ში, რადგან სერვერები არის **გრძელი ხნის** — ნელი გაჟონვა, რომელიც უხილავია განვითარებაში, თანდათან რელიტოვდება და საბოლოოდ ჩამოვარდება საწარმო პროცესი (ხშირად თავიდან აკეთებს და კარგავს ფრენის დროს შინაარსი).

კლასიკური წყაროების ცოდნა (შეუზღუდო caches, ამოუღები listeners/timers, დაკავებული closures), როგორ აღმოაჩენ მათ (heap monitoring + snapshot შედარება DevTools/clinic.js-თან), და შესწორებები (შეზღუდული LRU caches, დისციპლინირებული დასუფთავება, `WeakMap`) აუცილებელია საიმედო, სტაბილური Node სერვისების ექსპლოატაციისთვის დროთა განმავლობაში.