Wie erkennt und beheben Sie Speicherlecks in Node.js?

Question

Accepted Answer

Ein **Speicherleck** ist Speicher, der nicht mehr benötigt wird, aber nie freigegeben wird, weil etwas ihn noch referenziert. Im Laufe der Zeit wächst der Heap des Prozesses, bis er verlangsamt wird oder abstürzt (out-of-memory). In langfristig laufenden Node-Servern sind Lecks ein ernstes Problem in der Produktion.

## Häufige Leckquellen

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

Der gemeinsame Faden: eine erreichbare Referenz (eine globale Map, ein aktiver Listener, ein laufender Timer, eine Closure) hindert Objekte daran, garbage-collected zu werden, obwohl sie nicht mehr nützlich sind.

## Lecks erkennen

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

Der Diagnoseprozess: bestätigen Sie, dass der Heap stetig wächst (nicht nur normale Schwankungen), dann nehmen Sie **Heap-Snapshots** vor/nach einer Arbeitslast und vergleichen Sie, um herauszufinden, welche Objekttypen sich ansammeln ("retained size" wächst).

## Lecks beheben

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

Die Fixes spiegeln die Ursachen wider: begrenzte Caches (LRU mit Maximalgröße/TTL), immer Listener/Timer-Erstellung mit Cleanup koppeln, und `WeakMap`/`WeakSet` für objektschlüsselverschlüsselte Metadaten verwenden, die Objekte nicht im Speicher festhalten sollten.

## Warum es wichtig ist

Speicherlecks sind in Node besonders gefährlich, weil Server **langfristig laufen** — ein langsames Leck, das in der Entwicklung unsichtbar ist, verschlechtert sich allmählich und führt schließlich zum Absturz eines Produktionsprozesses (oft mit Neustart und Verlust laufender Arbeiten).

Die klassischen Quellen (unbegrenzte Caches, nicht entfernte Listener/Timer, verweilende Closures) zu kennen, wie man sie erkennt (Heap-Monitoring + Snapshot-Vergleich mit DevTools/clinic.js), und die Fixes (begrenzte LRU-Caches, diszipliniertesCleanup, `WeakMap`) sind essentiell für den Betrieb zuverlässiger, stabiler Node-Services über die Zeit hinweg.