1단계 - Mark (표시):
GC Root로부터 시작해서 도달 가능한(Reachable) 모든 객체를 표시해.

2단계 - Sweep (제거):
표시되지 않은 객체들을 메모리에서 제거해.

3단계 - Compact (압축, 선택적):
메모리 단편화를 방지하기 위해 살아남은 객체들을 한쪽으로 모아.

public class MemoryLeakExample {
    private static List<Object> list = new ArrayList<>();
    
    public void addObject() {
        // 계속 추가만 하고 제거하지 않으면 메모리 누수!
        list.add(new Object());
    }
}

public class EventManager {
    private List<EventListener> listeners = new ArrayList<>();
    
    public void addListener(EventListener listener) {
        listeners.add(listener);
    }
    
    // 문제: removeListener 메서드가 없거나 호출되지 않음
    // 리스너 객체가 계속 메모리에 남아있게 됨
}

public class CacheManager {
    private Map<String, Object> cache = new HashMap<>();
    
    public void put(String key, Object value) {
        cache.put(key, value);
        // 문제: 오래된 항목을 제거하는 로직이 없음
    }
}

public class ThreadLocalExample {
    private static ThreadLocal<HeavyObject> threadLocal = new ThreadLocal<>();
    
    public void process() {
        threadLocal.set(new HeavyObject());
        // 작업 수행
        // 문제: threadLocal.remove()를 호출하지 않음
    }
}

public void readFile(String path) throws IOException {
    FileInputStream fis = new FileInputStream(path);
    // 파일 읽기
    // 문제: fis.close()를 호출하지 않음
    // try-with-resources를 사용하는 게 안전!
}

// 올바른 방법
public void readFileSafely(String path) throws IOException {
    try (FileInputStream fis = new FileInputStream(path)) {
        // 파일 읽기
    } // 자동으로 close() 호출됨
}

public class OuterClass {
    private byte[] data = new byte[1024 * 1024]; // 1MB
    
    public class InnerClass {
        public void doSomething() {
            // InnerClass는 OuterClass의 참조를 암묵적으로 가짐
            // InnerClass 인스턴스가 살아있으면 OuterClass도 GC 안 됨
        }
    }
}

# 살아있는 객체만 덤프 (권장)
jmap -dump:live,format=b,file=heap_dump_$(date +%Y%m%d_%H%M%S).hprof [PID]

# 모든 객체 덤프
jmap -dump:format=b,file=heap_dump.hprof [PID]

# OutOfMemoryError 발생 시 자동으로 힙 덤프 생성
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/logs/heapdump.hprof \
     -jar myapp.jar

import com.sun.management.HotSpotDiagnosticMXBean;
import java.lang.management.ManagementFactory;

public class HeapDumper {
    public static void dumpHeap(String filePath, boolean live) throws Exception {
        HotSpotDiagnosticMXBean mxBean = ManagementFactory.getPlatformMXBean(
            HotSpotDiagnosticMXBean.class
        );
        mxBean.dumpHeap(filePath, live);
    }
}

Problem Suspect 1:
"One instance of com.example.CacheManager loaded by sun.misc.Launcher$AppClassLoader occupies 512 MB (85% of total heap)."

Class Name                    | Objects | Shallow Heap | Retained Heap
------------------------------|---------|--------------|---------------
byte[]                        | 125,432 |   45,234 KB  |   45,234 KB
java.lang.String              |  98,765 |    3,950 KB  |   49,184 KB
com.example.User              |  50,000 |    2,400 KB  |   12,500 KB
java.util.HashMap$Node        |  45,678 |    1,827 KB  |    1,827 KB

객체 우클릭 → Path to GC Roots → exclude weak/soft references

GC Root: Thread "main"
  ↓
com.example.Application (local variable)
  ↓
com.example.ServiceManager (field: serviceManager)
  ↓
java.util.ArrayList (field: services)
  ↓
com.example.CacheService (element)
  ↓
java.util.HashMap (field: cache)
  ↓
com.example.User[] (value) ← 여기가 문제!

-- 특정 클래스의 모든 인스턴스 찾기
SELECT * FROM com.example.User

-- 특정 필드 값으로 필터링
SELECT * FROM com.example.User WHERE name = "John"

-- 큰 객체만 찾기
SELECT * FROM java.util.HashMap WHERE size() > 10000

-- 특정 패턴의 문자열 찾기
SELECT * FROM java.lang.String s WHERE s.toString() LIKE ".*cache.*"

public class UserSessionManager {
    private static Map<String, UserSession> sessions = new HashMap<>();
    
    public void createSession(String sessionId, User user) {
        UserSession session = new UserSession(user);
        sessions.put(sessionId, session);
        // 문제: 세션을 제거하는 로직이 없음!
    }
    
    public UserSession getSession(String sessionId) {
        return sessions.get(sessionId);
    }
}

public class UserSessionManager {
    // WeakHashMap 사용 또는 만료 정책 구현
    private static Map<String, UserSession> sessions = 
        new ConcurrentHashMap<>();
    
    private static final long SESSION_TIMEOUT = 30 * 60 * 1000; // 30분
    
    public void createSession(String sessionId, User user) {
        UserSession session = new UserSession(user);
        session.setCreatedTime(System.currentTimeMillis());
        sessions.put(sessionId, session);
    }
    
    public void removeSession(String sessionId) {
        sessions.remove(sessionId);
    }
    
    // 주기적으로 만료된 세션 정리
    @Scheduled(fixedRate = 60000) // 1분마다
    public void cleanupExpiredSessions() {
        long now = System.currentTimeMillis();
        sessions.entrySet().removeIf(entry -> 
            now - entry.getValue().getCreatedTime() > SESSION_TIMEOUT
        );
    }
}

public class DataPanel extends JPanel {
    private DataModel model;
    
    public DataPanel(DataModel model) {
        this.model = model;
        // 리스너 등록
        model.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                updateUI();
            }
        });
    }
    
    // 문제: 패널이 제거될 때 리스너를 해제하지 않음
}

public class DataPanel extends JPanel {
    private DataModel model;
    private ChangeListener changeListener;
    
    public DataPanel(DataModel model) {
        this.model = model;
        
        // 리스너를 필드로 저장
        this.changeListener = new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                updateUI();
            }
        };
        
        model.addChangeListener(changeListener);
    }
    
    // 패널 제거 시 리스너 해제
    @Override
    public void removeNotify() {
        super.removeNotify();
        if (model != null && changeListener != null) {
            model.removeChangeListener(changeListener);
        }
    }
    
    // 또는 WeakReference 사용
    public void addWeakListener() {
        model.addChangeListener(new WeakChangeListener(changeListener));
    }
}

public class RequestContext {
    private static ThreadLocal<UserContext> userContext = new ThreadLocal<>();
    
    public static void setUserContext(UserContext context) {
        userContext.set(context);
    }
    
    public static UserContext getUserContext() {
        return userContext.get();
    }
    
    // 문제: ThreadLocal을 정리하는 메서드가 없음
}

public class RequestContext {
    private static ThreadLocal<UserContext> userContext = new ThreadLocal<>();
    
    public static void setUserContext(UserContext context) {
        userContext.set(context);
    }
    
    public static UserContext getUserContext() {
        return userContext.get();
    }
    
    // ThreadLocal 정리 메서드 추가
    public static void clear() {
        userContext.remove();
    }
}

// 서블릿 필터에서 요청 처리 후 정리
public class RequestContextFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        try {
            chain.doFilter(request, response);
        } finally {
            // 반드시 정리!
            RequestContext.clear();
        }
    }
}

public class ImageCache {
    private static Map<String, BufferedImage> cache = new HashMap<>();
    
    public BufferedImage getImage(String url) throws IOException {
        if (!cache.containsKey(url)) {
            BufferedImage image = ImageIO.read(new URL(url));
            cache.put(url, image);
        }
        return cache.get(url);
    }
    
    // 문제: 캐시 크기 제한이 없고, 만료 정책도 없음
}

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class ImageCache {
    private static LoadingCache<String, BufferedImage> cache = 
        CacheBuilder.newBuilder()
            .maximumSize(1000)  // 최대 1000개
            .expireAfterAccess(30, TimeUnit.MINUTES)  // 30분 후 만료
            .weakValues()  // 메모리 부족 시 GC 가능
            .build(new CacheLoader<String, BufferedImage>() {
                @Override
                public BufferedImage load(String url) throws IOException {
                    return ImageIO.read(new URL(url));
                }
            });
    
    public BufferedImage getImage(String url) throws ExecutionException {
        return cache.get(url);
    }
}

# Prometheus Alert Rule
groups:
  - name: jvm_alerts
    rules:
      - alert: HighHeapUsage
        expr: jvm_memory_used_bytes{area="heap"} / jvm_memory_max_bytes{area="heap"} > 0.85
        for: 5m
        annotations:
          summary: "High heap usage detected"
          description: "Heap usage is above 85% for 5 minutes"
      
      - alert: FrequentFullGC
        expr: rate(jvm_gc_collection_seconds_count{gc="PS MarkSweep"}[1h]) > 5
        for: 10m
        annotations:
          summary: "Frequent Full GC detected"
          description: "More than 5 Full GCs per hour"