ਤੁਸ ਨੋਡ.ਜੇਐਸ ਵਿੱਚ ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਕਿਵੇਂ ਖੋਜਦੇ ਅਤੇ ਠੀਕ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

ਇੱਕ **memory leak** ਮੈਮੋਰੀ ਹੈ ਜੋ ਹੁਣ ਜਰੂਰੀ ਨਹੀਂ ਹੈ ਪਰ ਕਦੇ ਮੁਕਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਕਿਉਂਕਿ ਕੁਝ ਵੀ ਹਾਲੇ ਵੀ ਇਸਦਾ ਸੁਅੰਸ ਲੈ ਰਿਹਾ ਹੈ। ਸਮੇਂ ਦੇ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਦਾ heap ਵਧਦਾ ਹੈ ਜਦ ਤੱਕ ਇਹ ਹੌਲਾ ਨਹੀਂ ਹੋ ਜਾਂਦਾ ਜਾਂ ਨਹੀਂ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ (out-of-memory)। ਲੰਬੇ ਸਮੇਂ ਚਲਣ ਵਾਲੇ Node ਸਰਵਰਾਂ ਵਿੱਚ, leaks ਇੱਕ ਗੰਭੀਰ ਉਤਪਾਦਨ ਚਿੰਤਾ ਹਨ।

## ਆਮ leak ਸਰੋਤ

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

ਆਮ ਥਿੰਡ: ਇੱਕ reachable reference (ਇੱਕ global Map, ਇੱਕ live listener, ਇੱਕ ਚੱਲ ਰਹਾ timer, ਇੱਕ closure) ਵਸਤੂਆਂ ਨੂੰ garbage-collected ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਭਾਵੇਂ ਉਹ ਹੁਣ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।

## Leaks ਦੀ ਖੋਜ ਕਰਨਾ

```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 ਨਿਰੰਤਰ ਵਧਦਾ ਹੈ (ਸਿਰਫ ਸਾਧਾਰਣ ਉਤਰ-ਚੜ੍ਹ ਨਹੀਂ), ਫਿਰ ਇੱਕ workload ਤੋਂ ਪਹਿਲਾਂ/ਬਾਅਦ ਵਿੱਚ **heap snapshots** ਲਓ ਅਤੇ ਤੁਲਨਾ ਕਰੋ ਕਿ ਕਿਹੜੀਆਂ ਵਸਤੂ ਕਿਸਮਾਂ ਜਮ ਹੋ ਰਹੀਆਂ ਹਨ ("retained size" ਵਧ ਰਿਹਾ ਹੈ)।

## Leaks ਨੂੰ ਠੀਕ ਕਰਨਾ

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

ਫਿਕਸ ਕਾਰਨਾਂ ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕਰਦੇ ਹਨ: bounded caches (LRU ਅਧਿਕਤਮ ਆਕਾਰ/TTL ਦੇ ਨਾਲ), ਹਮੇਸ਼ਾ listener/timer ਨਿਰਮਾਣ ਨੂੰ cleanup ਦੇ ਨਾਲ ਜੋੜੋ, ਅਤੇ `WeakMap`/`WeakSet` ਦੀ ਵਰਤੋਂ ਕਰੋ ਆਬਜੈਕਟ-ਕੀਡ metadata ਲਈ ਜੋ ਮੈਮੋਰੀ ਵਿੱਚ ਵਸਤੂਆਂ ਨੂੰ ਪਿਨ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ।

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Memory leaks Node ਵਿੱਚ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਖਤਰਨਾਕ ਹਨ ਕਿਉਂਕਿ ਸਰਵਰ **ਲੰਬੇ ਸਮੇਂ ਚਲਣ ਵਾਲੇ** ਹਨ — ਇੱਕ ਆਹਸਤਾ leak ਜੋ development ਵਿੱਚ ਅਦਿੱਖ ਹੈ ਹੌਲੇ-ਹੌਲੇ ਇੱਕ production process ਨੂੰ ਭ੍ਰਸ਼ਟ ਕਰਦਾ ਹੈ ਅਤੇ ਆਖਿਰਕਾਰ ਕ੍ਰੈਸ਼ ਕਰਦਾ ਹੈ (ਅਕਸਰ ਮੁੜ ਸ਼ੁਰੂ ਅਤੇ in-flight ਕੰਮ ਗੁਆ ਕੇ)।

ਕਲਾਸਿਕ ਸਰੋਤਾਂ ਨੂੰ ਜਾਣਨਾ (unbounded caches, ਹਟਾਏ ਨਹੀਂ ਗਏ listeners/timers, ਲਾਗਿਸ਼ਮ closures), ਉਨ੍ਹਾਂ ਦੀ ਖੋਜ ਕਰਨਾ (heap monitoring + snapshot comparison ਨਾਲ DevTools/clinic.js), ਅਤੇ fixes (bounded LRU caches, ਅਨੁਸ਼ਾਸਿਤ cleanup, `WeakMap`) ਭਰੋਸੇਯੋਗ, ਸਥਿਰ Node ਸੇਵਾਵਾਂ ਨੂੰ ਸਮੇਂ ਦੇ ਨਾਲ ਚਲਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।