JVM 메모리 누수 패턴과 해결법

// ❌ 누수: static Map에 계속 추가만 함
public class CacheManager {
    private static final Map<String, Object> cache = new HashMap<>();
 
    public void addToCache(String key, Object value) {
        cache.put(key, value);  // 계속 쌓임
        // remove()를 호출하지 않으면 → 메모리 누수
    }
}

// ✅ 해결: 크기 제한이 있는 캐시 사용
public class CacheManager {
    private static final Map<String, Object> cache = new LinkedHashMap<>() {
        @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return size() > 100;  // 100개 초과 시 가장 오래된 항목 자동 제거
        }
    };
}

// ❌ 누수: 이벤트 리스너 등록 후 해제하지 않음
public class DataProcessor {
    public void init() {
        EventBus.register(this);  // 등록
        // 객체가 더 이상 필요 없어도 EventBus가 참조를 유지
        // → GC 불가 → 메모리 누수
    }
}

// ✅ 해결: 사용 후 반드시 해제
public class DataProcessor implements AutoCloseable {
    public void init() {
        EventBus.register(this);
    }
 
    @Override
    public void close() {
        EventBus.unregister(this);  // 반드시 해제
    }
}

// ❌ 누수: 예외 발생 시 close()가 호출되지 않음
public String readFile(String path) throws IOException {
    FileInputStream fis = new FileInputStream(path);
    byte[] data = fis.readAllBytes();  // ← 여기서 예외 발생하면?
    fis.close();                        // ← 이 줄은 실행되지 않음
    return new String(data);
}

// ✅ 해결: try-with-resources 사용
public String readFile(String path) throws IOException {
    try (FileInputStream fis = new FileInputStream(path)) {
        return new String(fis.readAllBytes());
        // try 블록 종료 시 자동으로 close() 호출
        // 예외가 발생해도 반드시 닫힘
    }
}

// ❌ 누수: 익명 클래스가 Server 인스턴스 전체를 참조
public class Server {
    private byte[] largeData = new byte[10_000_000]; // 10MB
 
    public Runnable createTask() {
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("작업 실행");
                // largeData를 사용하지 않지만, Server 인스턴스 전체를 참조
            }
        };
    }
}

// ✅ 해결: 람다 또는 static 내부 클래스 사용
public class Server {
    private byte[] largeData = new byte[10_000_000];
 
    public Runnable createTask() {
        return () -> System.out.println("작업 실행");
        // 람다는 캡처하는 변수만 참조 → Server 인스턴스 참조 없음
    }
}

// ❌ 누수: 매 요청마다 새 HttpClient + SslContext 생성
@Service
public class ApiService {
 
    public String callExternalApi(String url) {
        // 매번 새로 생성 → SSL 핸드셰이크마다 네이티브 버퍼 할당
        SslContext sslContext = SslContextBuilder.forClient()
            .trustManager(InsecureTrustManagerFactory.INSTANCE)
            .build();
 
        HttpClient httpClient = HttpClient.create()
            .secure(spec -> spec.sslContext(sslContext));
 
        WebClient client = WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient))
            .build();
 
        return client.get().uri(url)
            .retrieve().bodyToMono(String.class).block();
    }
}

// ✅ 해결: 싱글톤으로 한 번만 생성하여 재사용
@Configuration
public class WebClientConfig {
 
    @Bean
    public WebClient webClient() throws SSLException {
        SslContext sslContext = SslContextBuilder.forClient()
            .trustManager(InsecureTrustManagerFactory.INSTANCE)
            .build();
 
        HttpClient httpClient = HttpClient.create()
            .secure(spec -> spec.sslContext(sslContext))
            .responseTimeout(Duration.ofSeconds(5));
 
        return WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(httpClient))
            .build();
    }
}
 
@Service
@RequiredArgsConstructor
public class ApiService {
    private final WebClient webClient;  // 주입받아 재사용
 
    public String callExternalApi(String url) {
        return webClient.get().uri(url)
            .retrieve().bodyToMono(String.class).block();
    }
}

// ❌ 누수: 루프 안에서 Direct 버퍼를 대량 생성
public void processData() {
    for (int i = 0; i < 100_000; i++) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB
        // 사용 후 명시적 해제 없음
        // GC가 래퍼 객체를 수거할 때까지 네이티브 메모리 점유
    }
}

// ✅ 해결: 버퍼를 한 번 할당하고 재사용
public void processData() {
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB
    for (int i = 0; i < 100_000; i++) {
        buffer.clear();  // 위치만 초기화, 메모리 재할당 없음
        // 데이터 처리
    }
}

// ❌ 누수: 요청마다 스레드 생성, 종료 없음
public void handleRequest() {
    new Thread(() -> {
        while (true) {  // 영원히 실행
            // 작업
        }
    }).start();  // 요청마다 스레드 생성 → 무한 증가
}

// ✅ 해결: 스레드 풀 사용
private final ExecutorService executor = Executors.newFixedThreadPool(10);
 
public void handleRequest() {
    executor.submit(() -> {
        // 작업 완료 후 스레드가 풀로 반환됨
    });
}