memory-management

Diagnose and resolve memory issues in production systems. Outputs heap analysis, leak detection strategies, GC tuning recommendations, and memory-efficient design patterns.

설치로 이동

저장소: kalilurrahman/kr-claudiator-skills
최근 소스 활동: 2026년 3월 24일 13:16
감지된 SKILL.md 언어: 영어
스타: 1
포크: 0

설치 방법

기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.

소스 파일 검토

설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.

검색으로 돌아가기 설치로 돌아가기

# JVM — trigger heap dump
jmap -dump:format=b,file=heap.hprof <pid>
# Then analyse in Eclipse MAT or VisualVM

# Node.js — heap snapshot via v8
node --inspect app.js
# In Chrome DevTools → Memory → Take Heap Snapshot

# Python — tracemalloc
import tracemalloc
tracemalloc.start()
# ... run suspect code ...
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)

# Go — pprof
import _ "net/http/pprof"
# GET /debug/pprof/heap → download and analyse:
go tool pprof -http=:8080 heap.out

# LEAK 1: Event listeners never removed
class DataProcessor:
    def __init__(self, event_bus):
        self._handlers = []
        # BAD: lambda captures self, never unregistered
        event_bus.on('data', lambda d: self.process(d))
    
    # FIX: Track and unsubscribe
    def __init__(self, event_bus):
        self._event_bus = event_bus
        self._handler = self._on_data
        event_bus.on('data', self._handler)
    
    def _on_data(self, data):
        self.process(data)
    
    def shutdown(self):
        self._event_bus.off('data', self._handler)

# LEAK 2: Unbounded cache
cache = {}  # grows forever

# FIX: LRU cache with size limit
from functools import lru_cache
from cachetools import LRUCache, cached

cache = LRUCache(maxsize=1000)

@cached(cache)
def expensive_lookup(key):
    return fetch_from_db(key)

# LEAK 3: Thread-local storage not cleared
import threading
_local = threading.local()

def handle_request(user_id):
    _local.user_id = user_id  # set but never cleared
    process()

# FIX: Always clean up
def handle_request(user_id):
    _local.user_id = user_id
    try:
        process()
    finally:
        del _local.user_id  # clean up after request

# LEAK 4: Circular references (pre-Python 3.4 or with __del__)
class Node:
    def __init__(self):
        self.children = []
        self.parent = None  # circular: child → parent → child

# FIX: Use weakref for back-references
import weakref
class Node:
    def __init__(self):
        self.children = []
        self._parent = None
    
    @property
    def parent(self):
        return self._parent() if self._parent else None
    
    @parent.setter
    def parent(self, node):
        self._parent = weakref.ref(node) if node else None

# G1GC (default Java 9+) — recommended for most workloads
-XX:+UseG1GC
-Xms4g -Xmx4g          # Set min=max to prevent heap resizing
-XX:MaxGCPauseMillis=200  # Target pause time
-XX:G1HeapRegionSize=16m  # Larger regions for large objects
-XX:InitiatingHeapOccupancyPercent=45

# ZGC — for latency-sensitive (<10ms pauses)
-XX:+UseZGC
-Xmx16g
-XX:ConcGCThreads=4

# GC logging (always enable in production)
-Xlog:gc*:file=/var/log/app/gc.log:time,uptime:filecount=5,filesize=20m

# Diagnose GC issues
# High allocation rate → increase Eden space or reduce object creation
# Long GC pauses → reduce heap size or switch GC algorithm
# Frequent full GC → likely leak or undersized old gen

# G1GC problem flags
-XX:+PrintGCDetails        # Detailed GC logs
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/tmp/heapdump.hprof

// Set heap limit explicitly (default is ~1.5GB)
// node --max-old-space-size=4096 app.js

// Monitor heap in code
function logMemory() {
  const used = process.memoryUsage();
  console.log({
    heapUsed: `${Math.round(used.heapUsed / 1024 / 1024)}MB`,
    heapTotal: `${Math.round(used.heapTotal / 1024 / 1024)}MB`,
    external: `${Math.round(used.external / 1024 / 1024)}MB`,
    rss: `${Math.round(used.rss / 1024 / 1024)}MB`,
  });
}

// Detect leaks — heap growing between GC cycles
const v8 = require('v8');
setInterval(() => {
  const stats = v8.getHeapStatistics();
  if (stats.used_heap_size > stats.heap_size_limit * 0.85) {
    console.warn('Heap usage >85% — possible leak');
  }
}, 30000);

// Stream large datasets — never buffer entire result
// BAD
async function exportAll() {
  const rows = await db.query('SELECT * FROM events'); // millions of rows
  return JSON.stringify(rows); // OOM
}

// GOOD
async function exportAll(res) {
  const stream = db.queryStream('SELECT * FROM events');
  stream.pipe(new JSONTransformStream()).pipe(res);
}

package main

import (
    "net/http"
    _ "net/http/pprof"
    "runtime"
)

func main() {
    // Enable pprof endpoint
    go http.ListenAndServe(":6060", nil)
    
    // Manual GC stats
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Alloc: %v MB\n", m.Alloc/1024/1024)
    fmt.Printf("Sys: %v MB\n", m.Sys/1024/1024)
    fmt.Printf("NumGC: %v\n", m.NumGC)
}

// Capture and analyse:
// go tool pprof http://localhost:6060/debug/pprof/heap
// go tool pprof http://localhost:6060/debug/pprof/goroutine  # goroutine leaks

// Common Go leak: goroutines blocked on channels that never close
func leaky(ch <-chan int) {
    go func() {
        for v := range ch { // goroutine leaks if ch never closed
            process(v)
        }
    }()
}

// Fix: use context cancellation
func fixed(ctx context.Context, ch <-chan int) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                return
            case v, ok := <-ch:
                if !ok { return }
                process(v)
            }
        }
    }()
}

Pattern	When to Use	Memory Saving
Object pooling	Frequent allocation/deallocation of same-size objects	Eliminates GC pressure
Flyweight	Many objects sharing common state	Share immutable state
Lazy loading	Large objects not always needed	Defer until accessed
Streaming	Processing large datasets	O(1) instead of O(n) memory
Off-heap storage	JVM: large caches that cause GC	Bypass GC entirely
Weak references	Caches that should yield under pressure	Auto-eviction by GC

Anti-Pattern	Problem	Fix
Infinite in-memory cache	Grows until OOM	LRU/TTL eviction
Unsubscribed listeners	Event handlers hold object graphs alive	Explicit lifecycle/teardown
Large object graphs in sessions	HTTP sessions retaining megabytes per user	Store only session IDs; fetch from cache
Heap dumps in prod without trigger	Performance hit, disk fill	Only on OOM or explicit operator trigger
GC tuning before fixing leaks	Masks root cause	Fix leaks first
Unbounded queues	Worker queues grow under load	Bounded queues with backpressure
String interning abuse	Interned strings never GC'd	Only intern truly global constants