Java 성능/JVM 완전 정리

Java code

// JVM 메모리 구조 이해를 위한 코드

public class JvmMemory {

    // static 변수 — Method Area (Metaspace)
    private static final int MAX_SIZE = 1000;
    private static int instanceCount = 0;

    // 인스턴스 변수 — Heap
    private final int id;
    private byte[] data;

    public JvmMemory(int size) {
        this.id   = ++instanceCount;
        this.data = new byte[size];  // Heap 할당
    }

    public static void main(String[] args) {
        // JVM 옵션 예시:
        // -Xms512m      : 초기 Heap 크기
        // -Xmx2g        : 최대 Heap 크기
        // -XX:+UseG1GC  : G1 GC 사용
        // -XX:+UseZGC   : ZGC (Java 15+, 저지연)
        // -verbose:gc   : GC 로그 출력

        // Runtime으로 메모리 정보 확인
        Runtime rt = Runtime.getRuntime();
        System.out.println("가용 프로세서: " + rt.availableProcessors());
        System.out.printf("총 메모리: %,d bytes%n", rt.totalMemory());
        System.out.printf("최대 메모리: %,d bytes%n", rt.maxMemory());
        System.out.printf("사용 가능: %,d bytes%n", rt.freeMemory());

        // 메모리 누수 예시 — static 컬렉션에 계속 추가
        // static List<Object> leaky = new ArrayList<>();
        // while(true) leaky.add(new byte[1024]);  // OOM!

        // 약한 참조 — GC가 회수 가능
        var weakRef = new java.lang.ref.WeakReference<>(new byte[1024]);
        System.gc(); // 힌트 (보장 안 됨)
        System.out.println("약한 참조 살아있나: " + (weakRef.get() != null));

        // String intern — String Pool 활용
        String s1 = new String("hello").intern();
        String s2 = "hello";
        System.out.println(s1 == s2); // true (같은 Pool 객체)

        // 효율적인 객체 생성
        // Bad:  for(int i=0;i<1000;i++) new Integer(i);
        // Good: Integer.valueOf(i) — 캐시 활용 (-128~127)
    }
}

// GC 알고리즘 비교 (JVM 옵션):
// Serial GC    : -XX:+UseSerialGC     (단일 스레드, 소형 앱)
// Parallel GC  : -XX:+UseParallelGC   (처리량 우선)
// G1 GC        : -XX:+UseG1GC         (Java 9+ 기본, 균형)
// ZGC          : -XX:+UseZGC          (Java 15+, 초저지연 <1ms)
// Shenandoah   : -XX:+UseShenandoahGC (RedHat, 저지연)

Java code

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.*;
import java.util.concurrent.TimeUnit;

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
public class StringConcatBenchmark {

    @Param({"10", "100", "1000"})
    int count;

    private String[] words;

    @Setup
    public void setup() {
        words = new String[count];
        for (int i = 0; i < count; i++) {
            words[i] = "word" + i;
        }
    }

    @Benchmark
    public String stringPlus() {
        String result = "";
        for (String w : words) result += w;
        return result;
    }

    @Benchmark
    public String stringBuilder() {
        var sb = new StringBuilder(count * 6);
        for (String w : words) sb.append(w);
        return sb.toString();
    }

    @Benchmark
    public String stringJoin() {
        return String.join("", words);
    }

    @Benchmark
    public String streamCollect() {
        return Arrays.stream(words)
            .collect(java.util.stream.Collectors.joining());
    }

    // 실행 방법:
    // mvn package
    // java -jar target/benchmarks.jar
    // 또는
    // public static void main(String[] args) throws Exception {
    //     new Runner(new OptionsBuilder()
    //         .include(StringConcatBenchmark.class.getSimpleName())
    //         .build()).run();
    // }
}

Java code

// Java 22 — Foreign Function & Memory API (FFM)
import java.lang.foreign.*;
import java.lang.invoke.*;

public class PanamaDemo {
    public static void main(String[] args) throws Throwable {
        // 시스템 라이브러리 링킹
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();

        // strlen 함수 가져오기
        MethodHandle strlen = linker.downcallHandle(
            stdlib.find("strlen").orElseThrow(),
            FunctionDescriptor.of(
                ValueLayout.JAVA_LONG,   // 반환 타입: long
                ValueLayout.ADDRESS      // 인자 타입: pointer
            )
        );

        // Native 메모리 할당 (Arena로 수명 관리)
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment str =
                arena.allocateFrom("Hello, Panama!");

            long len = (long) strlen.invoke(str);
            System.out.println("strlen = " + len); // 14
        } // Arena 닫히면 자동 메모리 해제

        // StructLayout — C 구조체 매핑
        MemoryLayout pointLayout = MemoryLayout.structLayout(
            ValueLayout.JAVA_INT.withName("x"),
            ValueLayout.JAVA_INT.withName("y")
        );

        VarHandle xHandle = pointLayout.varHandle(
            MemoryLayout.PathElement.groupElement("x"));

        try (Arena arena = Arena.ofConfined()) {
            MemorySegment point = arena.allocate(pointLayout);
            xHandle.set(point, 0L, 42);
            System.out.println("x = " + xHandle.get(point, 0L));
        }

        System.out.println("FFM API — 네이티브 접근 성공!");
    }
}
// 컴파일: javac --enable-preview --release 22 PanamaDemo.java
// 실행:   java  --enable-preview PanamaDemo

Java code

<span class="cm">// JEP 445 Unnamed Classes 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("JEP 445 Unnamed Classes") }

Java code

// === GC 선택 가이드 ===

// 1. G1 GC (Java 9+ 기본) — 균형 잡힌 범용 GC
// java -XX:+UseG1GC -Xms4g -Xmx4g
//   -XX:MaxGCPauseMillis=200      # 목표 일시 정지 시간
//   -XX:G1HeapRegionSize=16m      # 리전 크기 (1~32MB)
//   -XX:InitiatingHeapOccupancyPercent=45  # 혼합 GC 시작 임계값
//   -Xlog:gc*:gc.log:time,tags    # GC 로그
//   -jar app.jar

// 2. ZGC (Java 15+) — 초저지연 (<1ms 일시 정지)
// java -XX:+UseZGC
//   -Xms4g -Xmx4g
//   -XX:+ZGenerational             # Java 21: 세대별 ZGC (권장)
//   -Xlog:gc*:gc.log:time,tags
//   -jar app.jar

// 3. 프로그래밍으로 GC 정보 조회
import java.lang.management.*;
import java.util.List;

public class GCMonitor {
    public static void printGCInfo() {
        List<GarbageCollectorMXBean> gcBeans =
            ManagementFactory.getGarbageCollectorMXBeans();

        for (GarbageCollectorMXBean gc : gcBeans) {
            System.out.printf("GC: %-20s 횟수: %d, 총 시간: %dms%n",
                gc.getName(), gc.getCollectionCount(),
                gc.getCollectionTime());
        }

        MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
        System.out.printf("힙 사용: %dMB / %dMB%n",
            mem.getHeapMemoryUsage().getUsed() / 1024 / 1024,
            mem.getHeapMemoryUsage().getMax() / 1024 / 1024);
    }

    public static void main(String[] args) {
        printGCInfo();
        // 할당 부하 테스트
        for (int i = 0; i < 100_000; i++) {
            byte[] tmp = new byte[1024];
        }
        printGCInfo();
    }
}

Java code

// JMH 벤치마크 실전 예시

// @BenchmarkMode(Mode.Throughput)
// @OutputTimeUnit(TimeUnit.MILLISECONDS)
// @State(Scope.Benchmark)
// @Warmup(iterations = 3)
// @Measurement(iterations = 5)
// @Fork(1)
// public class CollectionBenchmark {
//     @Param({"100", "10000", "1000000"})
//     int size;
//
//     List<Integer> arrayList;
//     LinkedList<Integer> linkedList;
//
//     @Setup
//     public void setup() {
//         arrayList = new ArrayList<>(IntStream.range(0, size)
//             .boxed().toList());
//         linkedList = new LinkedList<>(arrayList);
//     }
//
//     @Benchmark
//     public int arrayListGet() { return arrayList.get(size / 2); }
//
//     @Benchmark
//     public int linkedListGet() { return linkedList.get(size / 2); }
//
//     @Benchmark
//     public void arrayListIterate(Blackhole bh) {
//         for (int i : arrayList) bh.consume(i);
//     }
//
//     @Benchmark
//     public void linkedListIterate(Blackhole bh) {
//         for (int i : linkedList) bh.consume(i);
//     }
// }

class Main {
    public static void main(String[] args) {
        System.out.println("JMH 핵심 어노테이션:");
        System.out.println("@Benchmark: 벤치마크 메서드");
        System.out.println("@State: 상태 스코프 (Benchmark, Thread)");
        System.out.println("@Setup/@TearDown: 초기화/정리");
        System.out.println("@Param: 파라미터화된 벤치마크");
        System.out.println("Blackhole: 데드코드 제거 방지");
    }
}

Java code

// JFR — Java Flight Recorder (JDK 11+ 무료)

// 1. 명령줄로 JFR 시작
// java -XX:StartFlightRecording=duration=60s,filename=app.jfr MyApp

// 2. 실행 중 JFR 제어
// jcmd <pid> JFR.start name=profile duration=30s
// jcmd <pid> JFR.dump name=profile filename=dump.jfr
// jcmd <pid> JFR.stop name=profile

// 3. 프로그래밍 방식
import jdk.jfr.*;

@Label("사용자 요청")
@Category({"Application", "Request"})
@StackTrace(false)
class RequestEvent extends Event {
    @Label("경로") String path;
    @Label("응답시간(ms)") long responseTime;
    @Label("상태코드") int statusCode;
}

public class JFRDemo {
    static void handleRequest(String path) {
        RequestEvent event = new RequestEvent();
        event.begin();

        // 요청 처리 시뮬레이션
        long start = System.currentTimeMillis();
        try { Thread.sleep((long)(Math.random() * 100)); }
        catch (InterruptedException e) {}

        event.path = path;
        event.responseTime = System.currentTimeMillis() - start;
        event.statusCode = 200;
        event.commit(); // JFR에 기록
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            handleRequest("/api/users/" + i);
        }
        System.out.println("JFR 이벤트 기록 완료");
        System.out.println("JMC(JDK Mission Control)로 .jfr 파일 분석");
    }
}

Java code

// GC 옵션 비교
// -XX:+UseG1GC          — G1 (기본, Java 9+)
// -XX:+UseZGC            — ZGC (초저지연, Java 15+)
// -XX:+UseShenandoahGC   — Shenandoah (저지연)

// GC 로그 활성화
// java -Xlog:gc*:file=gc.log:time,level,tags MyApp

// 주요 GC 튜닝 파라미터
// -Xms4g -Xmx4g          — 힙 크기 (최소=최대 권장)
// -XX:MaxGCPauseMillis=200 — G1 목표 일시정지
// -XX:G1HeapRegionSize=16m — G1 리전 크기

public class GCAnalysis {
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();

        System.out.println("=== JVM 메모리 정보 ===");
        System.out.printf("최대 힙: %dMB%n", rt.maxMemory() / 1024 / 1024);
        System.out.printf("전체 힙: %dMB%n", rt.totalMemory() / 1024 / 1024);
        System.out.printf("사용 가능: %dMB%n", rt.freeMemory() / 1024 / 1024);

        // GC 정보
        java.lang.management.ManagementFactory.getGarbageCollectorMXBeans()
            .forEach(gc -> System.out.printf("GC: %s, 횟수: %d, 시간: %dms%n",
                gc.getName(), gc.getCollectionCount(), gc.getCollectionTime()));

        // 메모리 풀
        java.lang.management.ManagementFactory.getMemoryPoolMXBeans()
            .forEach(pool -> {
                var usage = pool.getUsage();
                if (usage != null && usage.getMax() > 0) {
                    System.out.printf("풀: %s, 사용: %dMB/%dMB%n",
                        pool.getName(),
                        usage.getUsed() / 1024 / 1024,
                        usage.getMax() / 1024 / 1024);
                }
            });
    }
}

Java code

// 힙 덤프 생성 방법

// 1. OOM 시 자동 생성
// java -XX:+HeapDumpOnOutOfMemoryError
//      -XX:HeapDumpPath=/tmp/heap.hprof MyApp

// 2. 수동 생성
// jcmd <pid> GC.heap_dump /tmp/heap.hprof
// jmap -dump:format=b,file=/tmp/heap.hprof <pid>

// 3. 프로그래밍 방식
import com.sun.management.HotSpotDiagnosticMXBean;
import java.lang.management.ManagementFactory;

public class HeapDumpAnalysis {
    static void dumpHeap(String path, boolean live) throws Exception {
        HotSpotDiagnosticMXBean bean = ManagementFactory
            .getPlatformMXBean(HotSpotDiagnosticMXBean.class);
        bean.dumpHeap(path, live); // live=true: GC 후 덤프
    }

    public static void main(String[] args) throws Exception {
        // 의도적 메모리 사용
        java.util.List<byte[]> leak = new java.util.ArrayList<>();
        for (int i = 0; i < 100; i++) {
            leak.add(new byte[1024 * 1024]); // 1MB씩
        }

        System.out.println("메모리 사용: " +
            (Runtime.getRuntime().totalMemory() -
             Runtime.getRuntime().freeMemory()) / 1024 / 1024 + "MB");

        // 분석 도구:
        // - Eclipse MAT (Memory Analyzer Tool)
        // - VisualVM
        // - JDK Mission Control
        System.out.println("분석 도구: Eclipse MAT, VisualVM, JMC");
        System.out.println("MAT의 Leak Suspects 리포트가 가장 유용합니다.");
    }
}

Java code

// 스레드 덤프 생성
// jcmd <pid> Thread.print
// jstack <pid>
// kill -3 <pid> (Unix)

import java.lang.management.*;

public class ThreadDumpAnalysis {
    public static void main(String[] args) throws Exception {
        // 데드락 시뮬레이션용 잠금 객체
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock2) { System.out.println("T1 완료"); }
            }
        }, "Thread-A");

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock1) { System.out.println("T2 완료"); }
            }
        }, "Thread-B");

        t1.start();
        t2.start();

        Thread.sleep(500);

        // 프로그래밍 방식으로 스레드 정보 확인
        ThreadMXBean tmx = ManagementFactory.getThreadMXBean();

        // 데드락 감지
        long[] deadlocked = tmx.findDeadlockedThreads();
        if (deadlocked != null) {
            System.out.println("데드락 감지!");
            for (ThreadInfo info : tmx.getThreadInfo(deadlocked, true, true)) {
                System.out.println(info);
            }
        }

        // 전체 스레드 상태
        for (ThreadInfo info : tmx.dumpAllThreads(true, true)) {
            System.out.printf("%s [%s]%n", info.getThreadName(), info.getThreadState());
        }
    }
}

Java code

// Caffeine 의존성: com.github.ben-manes.caffeine:caffeine:3.1+

// import com.github.ben-manes.caffeine.cache.*;

// Caffeine 캐시 설정 (의사코드)
// Cache<String, User> cache = Caffeine.newBuilder()
//     .maximumSize(10_000)              // 최대 항목 수
//     .expireAfterWrite(Duration.ofMinutes(5))  // 쓰기 후 만료
//     .expireAfterAccess(Duration.ofMinutes(1)) // 접근 후 만료
//     .recordStats()                    // 통계 기록
//     .build();

// 동기 로딩 캐시
// LoadingCache<String, User> loadingCache = Caffeine.newBuilder()
//     .maximumSize(10_000)
//     .expireAfterWrite(Duration.ofMinutes(5))
//     .build(key -> userRepository.findById(key)); // 캐시 미스 시 로딩

// 비동기 로딩 캐시
// AsyncLoadingCache<String, User> asyncCache = Caffeine.newBuilder()
//     .maximumSize(10_000)
//     .buildAsync(key -> userRepository.findByIdAsync(key));

// 간단한 캐시 구현
import java.util.*;
import java.util.concurrent.*;

class SimpleCache<K, V> {
    private final Map<K, V> store = new ConcurrentHashMap<>();
    private final Map<K, Long> expiry = new ConcurrentHashMap<>();
    private final long ttlMs;

    SimpleCache(long ttlMs) { this.ttlMs = ttlMs; }

    void put(K key, V value) {
        store.put(key, value);
        expiry.put(key, System.currentTimeMillis() + ttlMs);
    }

    Optional<V> get(K key) {
        Long exp = expiry.get(key);
        if (exp == null || System.currentTimeMillis() > exp) {
            store.remove(key);
            expiry.remove(key);
            return Optional.empty();
        }
        return Optional.ofNullable(store.get(key));
    }
}

class Main {
    public static void main(String[] args) {
        SimpleCache<String, String> cache = new SimpleCache<>(5000);
        cache.put("key", "value");
        System.out.println(cache.get("key")); // Optional[value]
    }
}

Java code

// 커넥션 풀 최적화 전략

public class ConnectionPoolTuning {
    public static void main(String[] args) {
        int cpuCores = Runtime.getRuntime().availableProcessors();

        // 최적 풀 크기 공식 (PostgreSQL 권장)
        // connections = (core_count * 2) + effective_spindle_count
        int optimalSize = cpuCores * 2 + 1;
        System.out.printf("CPU 코어: %d, 최적 풀 크기: %d%n", cpuCores, optimalSize);

        // HikariCP 권장 설정
        System.out.println("\n=== HikariCP 권장 설정 ===");
        System.out.println("maximumPoolSize: " + optimalSize);
        System.out.println("minimumIdle: " + optimalSize); // 고정 크기 권장
        System.out.println("connectionTimeout: 30000ms");
        System.out.println("idleTimeout: 600000ms (10분)");
        System.out.println("maxLifetime: 1800000ms (30분)");
        System.out.println("leakDetectionThreshold: 60000ms (1분)");

        // 모니터링 지표
        System.out.println("\n=== 모니터링 지표 ===");
        System.out.println("활성 커넥션 수 (active)");
        System.out.println("유휴 커넥션 수 (idle)");
        System.out.println("대기 스레드 수 (pending)");
        System.out.println("커넥션 획득 시간 (acquisition time)");
        System.out.println("커넥션 사용 시간 (usage time)");
        System.out.println("타임아웃 발생 횟수 (timeout count)");

        // 리틀의 법칙
        double avgResponseTime = 0.1; // 100ms
        double requestRate = 50; // 초당 50 요청
        double requiredConnections = avgResponseTime * requestRate;
        System.out.printf("\n리틀의 법칙: %.0f req/s * %.1fs = %.0f 커넥션 필요%n",
            requestRate, avgResponseTime, requiredConnections);
    }
}

Java code

// JIT 최적화 확인 옵션
// -XX:+PrintCompilation        — 컴파일 로그
// -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining — 인라인 로그

public class JITOptimization {
    // 1. 인라이닝 — 작은 메서드 호출을 제거
    static int add(int a, int b) { return a + b; }

    // 2. 이스케이프 분석 — 힙 할당을 스택으로
    static long sumPoints() {
        long sum = 0;
        for (int i = 0; i < 1_000_000; i++) {
            // JIT가 Point가 메서드 밖으로 나가지 않음을 감지
            // -> 힙 대신 스택에 할당 (스칼라 치환)
            var p = new int[]{i, i * 2}; // 이스케이프하지 않음
            sum += p[0] + p[1];
        }
        return sum;
    }

    // 3. 루프 최적화 — 언롤링, 벡터화
    static int arraySum(int[] arr) {
        int sum = 0;
        for (int v : arr) sum += v; // JIT가 SIMD 벡터화 가능
        return sum;
    }

    // 4. 데드 코드 제거
    static void deadCode() {
        int result = 0;
        for (int i = 0; i < 1000; i++) {
            result += i; // result를 사용하지 않으면 전체 루프 제거
        }
        // JIT가 결과가 사용되지 않음을 감지 -> 루프 제거
    }

    public static void main(String[] args) {
        // 워밍업 — JIT 컴파일 유도
        for (int i = 0; i < 10_000; i++) {
            sumPoints();
        }
        System.out.println("JIT 최적화 완료");
        System.out.println("합계: " + sumPoints());
    }
}

Java code

public class StringOptimization {
    public static void main(String[] args) {
        // 1. 문자열 연결: + vs StringBuilder
        // Java 9+에서 +는 invokedynamic으로 최적화
        // 루프에서는 여전히 StringBuilder가 유리
        StringBuilder sb = new StringBuilder(1000);
        for (int i = 0; i < 1000; i++) {
            sb.append("item").append(i).append(", ");
        }

        // 2. String.intern() — 중복 문자열 제거
        // 주의: intern() 테이블은 네이티브 메모리 사용
        String s1 = new String("hello").intern();
        String s2 = "hello";
        System.out.println(s1 == s2); // true

        // 3. compact strings (Java 9+)
        // 내부적으로 Latin1은 byte[], 유니코드는 UTF-16
        // 메모리 자동 절약 (별도 설정 불필요)

        // 4. 정규식 캐싱
        // Pattern은 한 번만 컴파일
        var pattern = java.util.regex.Pattern.compile("\\d+");
        for (int i = 0; i < 1000; i++) {
            pattern.matcher("abc123").find(); // 재사용
        }

        // 5. String.format vs StringBuilder
        // format()은 느림, 성능 중요 시 StringBuilder
        String fast = new StringBuilder()
            .append("이름: ").append("홍길동")
            .append(", 나이: ").append(30)
            .toString();

        System.out.println("최적화 완료: " + fast);
    }
}

Java code

import java.util.*;

public class CollectionSizing {
    public static void main(String[] args) {
        int expectedSize = 1000;

        // ArrayList — 기본 용량 10, 1.5배씩 증가
        // 1000개: 10->15->22->33->...->1076 (약 17번 재할당)
        List<String> badList = new ArrayList<>();       // 기본 10
        List<String> goodList = new ArrayList<>(expectedSize); // 1000

        // HashMap — 기본 용량 16, 로드팩터 0.75
        // 1000개 저장: 1000/0.75 = 1334 이상 필요
        Map<String, String> badMap = new HashMap<>();
        Map<String, String> goodMap = new HashMap<>(
            (int)(expectedSize / 0.75) + 1); // 1334

        // HashSet — HashMap 기반
        Set<String> goodSet = new HashSet<>(
            (int)(expectedSize / 0.75) + 1);

        // 성능 비교
        long start = System.nanoTime();
        for (int i = 0; i < expectedSize; i++) {
            badList.add("item" + i);
        }
        long badTime = System.nanoTime() - start;

        start = System.nanoTime();
        for (int i = 0; i < expectedSize; i++) {
            goodList.add("item" + i);
        }
        long goodTime = System.nanoTime() - start;

        System.out.printf("기본 용량: %dns%n", badTime);
        System.out.printf("최적 용량: %dns%n", goodTime);
        System.out.printf("개선: %.1f%%%n",
            (1.0 - (double)goodTime / badTime) * 100);
    }
}

Java code

import java.util.*;

public class MemoryLeakDetection {
    // 누수 패턴 1: static 컬렉션에 계속 추가
    static final List<byte[]> leakyCache = new ArrayList<>();

    // 누수 패턴 2: 리스너 미해제
    static final List<Runnable> listeners = new ArrayList<>();

    // 누수 패턴 3: 내부 클래스의 외부 참조
    class InnerClass {
        // 암묵적으로 OuterClass 참조 유지
        void doWork() { }
    }

    // 해결: WeakReference 사용
    static class SafeCache<K, V> {
        private final Map<K, java.lang.ref.WeakReference<V>> cache =
            new HashMap<>();

        void put(K key, V value) {
            cache.put(key, new java.lang.ref.WeakReference<>(value));
        }

        Optional<V> get(K key) {
            var ref = cache.get(key);
            if (ref == null) return Optional.empty();
            V value = ref.get();
            if (value == null) {
                cache.remove(key); // 정리
                return Optional.empty();
            }
            return Optional.of(value);
        }
    }

    public static void main(String[] args) {
        System.out.println("메모리 누수 탐지 방법:");
        System.out.println("1. -XX:+HeapDumpOnOutOfMemoryError");
        System.out.println("2. JFR로 객체 할당 추적");
        System.out.println("3. Eclipse MAT의 Leak Suspects");
        System.out.println("4. VisualVM 실시간 모니터링");

        System.out.println("\n주요 누수 패턴:");
        System.out.println("- static 컬렉션 무한 증가");
        System.out.println("- 이벤트 리스너 미해제");
        System.out.println("- 내부 클래스의 외부 참조");
        System.out.println("- 커넥션/스트림 미닫기");
        System.out.println("- ThreadLocal 미정리");
    }
}

Java code

public class PerformanceChecklist {
    public static void main(String[] args) {
        System.out.println("=== Java 성능 최적화 체크리스트 ===");

        System.out.println("\n[JVM 설정]");
        System.out.println("- Xms = Xmx (힙 크기 고정)");
        System.out.println("- 적절한 GC 선택 (G1/ZGC)");
        System.out.println("- HeapDumpOnOutOfMemoryError 활성화");
        System.out.println("- JFR 상시 활성화 (1% 미만 오버헤드)");

        System.out.println("\n[코드 레벨]");
        System.out.println("- 컬렉션 초기 용량 지정");
        System.out.println("- 루프에서 오토박싱 방지");
        System.out.println("- 불필요한 객체 생성 최소화");
        System.out.println("- Stream은 간결성 우선, 핫 경로는 for-loop");
        System.out.println("- Pattern 컴파일 캐싱");

        System.out.println("\n[동시성]");
        System.out.println("- 스레드 풀 크기: CPU*2+1 (CPU 바운드)");
        System.out.println("- I/O 바운드: Virtual Thread 사용");
        System.out.println("- ConcurrentHashMap > synchronizedMap");
        System.out.println("- Lock 경합 최소화");

        System.out.println("\n[I/O]");
        System.out.println("- 커넥션 풀 적정 크기");
        System.out.println("- 배치 처리 (JDBC batch)");
        System.out.println("- 로컬 캐시 (Caffeine)");
        System.out.println("- 비동기 I/O 활용");

        System.out.println("\n[측정]");
        System.out.println("- JMH로 마이크로벤치마크");
        System.out.println("- JFR/JMC로 프로파일링");
        System.out.println("- Micrometer + Prometheus 모니터링");
        System.out.println("- 변경 전후 반드시 측정");
    }
}