Conas a bhraithíonn tú agus a dhéanann tú deisiúint ar ghealadh cuimhne i Node.js?

Question

Accepted Answer

Is é **gealadh cuimhne** ná cuimhne nach bhfuil gá aici a thuilleadh ach nár scaoileadh riamh, toisc go bhfuil rud éigin fós ag tagairt di. Le himeall ama, fásann dréimire an phróisis go dtí go ndéantar é a bhrúchtadh nó a thuairteanna (cuimhne imithe). I bhfreastalacháin Node fada-bhuan, is gnáth-ghealadh gealadh a bheith ina bhagairt ar thábhacht an táirgthe.

## Foinsí coitianta gealadh

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

An snáithe coitianta: coimeádann tagairt a bhfuil rochtain ar a bhfuil ann (Léarscáil dhomhanda, éisteoir gníomhach, soithí imeall, dúnadh) rudaí ó bhailíonn bruscar fiú má nach bhfuil siad fóill i bhfeidhm.

## Gealadh a bhraistint

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

An próiseas diagnóiseach: dearbhaigh go fásann an dréimire go seasmhach (ní amháin foluain ghnáth), ansin tóg **snaidhmeanna dréimire** roimh/i ndiaidh oibre agus comparáid chun a fháil amach cé na cineálacha réada atá ag cruinniú ("retained size" ag fás).

## Gealadh a dhéanann deisiúint

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

Tagann na deisiúcháin na cúiseanna: taisce teorantach (LRU le dméid/TTL uachtar), ceangail i gcónaí cruthú éisteoir/soithí le glanadh, agus bain úsáid as `WeakMap`/`WeakSet` do metadata docht réada nach ba chóir go gcuirfeadh siad rudaí gréine.

## Cén fáth a bhfuil tábhacht aige

Is i gealadh cuimhne go háirithe i Node toisc go bhfuil freastalacháin **fada-bhuan** — gealadh mall atá dofheicthe i bhforbairt, go raibh sé ag laghdú de réir a chéile agus faoi dheireadh bris a phróiseas táirgthe (go minic atosú agus cailleadh oibre in-eitilt).

Aithne ar na foinsí clasaiceach (taiscí gan teorainn, éisteoirí/soithí baint, dúnadh fágtha), conas a bhraistint ar a bhfuil ann (monatóireacht dréimire + comparáid snaidhmeanna le DevTools/clinic.js), agus na deisiúcháin (taiscí LRU teorantach, glanadh smachtshuite, `WeakMap`) tá sé riachtanach do bhreith ar sheirbhísí Node iontaofa, cobhsaí thar am.