【保存版】Javaのメモリリーク対策完全ガイド2024 – 原因特定から修正まで7つの実践テクニック

   public class LeakExample {
       private static final List<Object> stored = new ArrayList<>();

       public void addData(Object data) {
           stored.add(data);  // staticリストへの追加は永続的な参照を作成
       }
   }

   public class Node {
       private Node next;
       private Object data;

       public void setNext(Node node) {
           this.next = node;  // 循環参照が発生する可能性
       }
   }

影響度の段階：
1. 軽度：定期的なGCで対応可能
2. 中度：パフォーマンス低下が顕著
3. 重度：OutOfMemoryError発生

　● サービス停止のリスク

public class StaticLeakExample {
    // 危険：制限のない静的コレクション
    private static final List<Session> activeSessions = new ArrayList<>();

    public void addSession(Session session) {
        activeSessions.add(session);  // セッションが無限に蓄積される可能性
    }

    // 改善案：期限切れセッションの削除メカニズムを実装
    public void cleanExpiredSessions() {
        activeSessions.removeIf(session -> session.isExpired());
    }
}

public class CacheLeakExample {
    private Map<String, byte[]> dataCache = new HashMap<>();

    // 危険：サイズ制限のないキャッシュ
    public void cacheData(String key, byte[] data) {
        dataCache.put(key, data);
    }

    // 改善案：LRUキャッシュの使用
    private Map<String, byte[]> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
        @Override
        protected boolean removeEldestEntry(Map.Entry<String, byte[]> eldest) {
            return size() > 100;  // キャッシュサイズを制限
        }
    };
}

public class ResourceLeakExample {
    // 危険：リソースが確実にクローズされない
    public void processFile(String path) throws IOException {
        FileInputStream fis = new FileInputStream(path);
        // 例外発生時にリソースがリークする可能性
        fis.read();
        fis.close();
    }

    // 改善案：try-with-resourcesの使用
    public void processFileCorrect(String path) throws IOException {
        try (FileInputStream fis = new FileInputStream(path)) {
            fis.read();
        }
    }
}

public class CacheImplementationExample {
    // 危険：WeakHashMapの誤用
    private Map<Key, Value> cache = new WeakHashMap<>();

    // 改善案：キャッシュエントリの有効期限管理
    private Cache<Key, Value> guavaCache = CacheBuilder.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build();
}

public class ListenerLeakExample {
    private List<DataChangeListener> listeners = new ArrayList<>();

    // 危険：リスナーが明示的に解除されない
    public void addListener(DataChangeListener listener) {
        listeners.add(listener);
    }

    // 改善案：WeakReferenceの使用
    private List<WeakReference<DataChangeListener>> safeListeners = 
        new ArrayList<>();

    public void addSafeListener(DataChangeListener listener) {
        safeListeners.add(new WeakReference<>(listener));
    }

    public void cleanupListeners() {
        safeListeners.removeIf(ref -> ref.get() == null);
    }
}

public class ThreadPoolLeakExample {
    // 危険：無制限のキューを持つスレッドプール
    ExecutorService executor = Executors.newFixedThreadPool(10);

    // 改善案：適切な境界値を設定したスレッドプール
    ExecutorService safeExecutor = new ThreadPoolExecutor(
        5, 10, // コアプール数と最大プール数
        60L, TimeUnit.SECONDS, // スレッド保持時間
        new ArrayBlockingQueue<>(1000), // 有界キュー
        new ThreadPoolExecutor.CallerRunsPolicy() // 拒否ポリシー
    );
}

public class InnerClassLeakExample {
    private byte[] largeData = new byte[1024 * 1024]; // 1MB

    // 危険：非staticな内部クラス
    private class DataProcessor {
        public void process() {
            // 外部クラスのlargeDataへの暗黙の参照を保持
        }
    }

    // 改善案：static内部クラスの使用
    private static class SafeDataProcessor {
        private final byte[] data;

        public SafeDataProcessor(byte[] data) {
            this.data = data;
        }

        public void process() {
            // 必要なデータのみを明示的に参照
        }
    }
}

# プロセスIDを指定してヒープダンプを取得
jmap -dump:format=b,file=heap.hprof <pid>

# OutOfMemoryError発生時に自動的にヒープダンプを取得する設定
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/path/to/dumps \
     -jar application.jar

   手順：
   1. File → Open Heap Dump
   2. Leak Suspects Report を選択
   3. レポートの生成を待機

-- 特定クラスのインスタンスを検索
SELECT * FROM java.lang.Class c 
WHERE c.name LIKE "com.example.%"

-- 大きなコレクションを特定
SELECT * FROM java.util.Collection c 
WHERE c.size > 10000

// JMX接続を有効にする起動オプション
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=9010
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false

<!-- metrics.xml -->
<config>
    <metrics>
        <heap-memory>
            <warning>80%</warning>
            <critical>90%</critical>
        </heap-memory>
        <gc-frequency>
            <warning>10/min</warning>
            <critical>20/min</critical>
        </gc-frequency>
    </metrics>
</config>

　　● 影響範囲の評価

public class CacheManager {
    // キーを弱参照で保持するWeakHashMap
    private final WeakHashMap<CacheKey, CacheValue> cache = new WeakHashMap<>();

    // カスタムキークラス
    public static class CacheKey {
        private final String identifier;

        public CacheKey(String identifier) {
            this.identifier = identifier;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof CacheKey)) return false;
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equals(identifier, cacheKey.identifier);
        }

        @Override
        public int hashCode() {
            return Objects.hash(identifier);
        }
    }

    // スレッドセーフな操作メソッド
    public synchronized void put(CacheKey key, CacheValue value) {
        cache.put(key, value);
    }

    public synchronized CacheValue get(CacheKey key) {
        return cache.get(key);
    }

    // 定期的なクリーンアップ
    public synchronized void cleanup() {
        System.gc();  // GCを促す
        // WeakHashMapは自動的に参照されていないキーを削除
    }
}

public class ResourceManager {
    // AutoCloseableを実装したカスタムリソース
    public static class ManagedResource implements AutoCloseable {
        private final ByteBuffer buffer;
        private boolean isClosed = false;

        public ManagedResource(int capacity) {
            this.buffer = ByteBuffer.allocateDirect(capacity);
        }

        public void writeData(byte[] data) {
            if (isClosed) {
                throw new IllegalStateException("Resource is closed");
            }
            buffer.put(data);
        }

        @Override
        public void close() {
            if (!isClosed) {
                // DirectByteBufferのクリーンアップ
                if (buffer instanceof DirectBuffer) {
                    ((DirectBuffer) buffer).cleaner().clean();
                }
                isClosed = true;
            }
        }
    }

    // try-with-resourcesを使用した安全なリソース操作
    public void processData(byte[] data) {
        try (ManagedResource resource = new ManagedResource(1024)) {
            resource.writeData(data);
            // リソースは自動的にクローズされる
        }
    }
}

public class SmartCache<K, V> {
    private final int maxSize;
    private final long expirationMillis;
    private final Map<K, CacheEntry<V>> cache;

    public SmartCache(int maxSize, long expirationSeconds) {
        this.maxSize = maxSize;
        this.expirationMillis = expirationSeconds * 1000;
        this.cache = Collections.synchronizedMap(
            new LinkedHashMap<K, CacheEntry<V>>(16, 0.75f, true) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<K, CacheEntry<V>> eldest) {
                    return size() > maxSize;
                }
            }
        );
    }

    private static class CacheEntry<V> {
        private final V value;
        private final long expirationTime;

        CacheEntry(V value, long expirationTime) {
            this.value = value;
            this.expirationTime = expirationTime;
        }

        boolean isExpired() {
            return System.currentTimeMillis() > expirationTime;
        }
    }

    public void put(K key, V value) {
        long expirationTime = System.currentTimeMillis() + expirationMillis;
        cache.put(key, new CacheEntry<>(value, expirationTime));
    }

    public Optional<V> get(K key) {
        CacheEntry<V> entry = cache.get(key);
        if (entry != null && !entry.isExpired()) {
            return Optional.of(entry.value);
        } else {
            cache.remove(key);
            return Optional.empty();
        }
    }

    // 定期的なクリーンアップ処理
    @Scheduled(fixedRate = 60000) // Spring Schedulerを使用する場合
    public void cleanup() {
        cache.entrySet().removeIf(entry -> entry.getValue().isExpired());
    }
}

@Configuration
public class BeanScopeConfig {
    // シングルトンスコープ（デフォルト）
    @Bean
    @Scope("singleton")
    public HeavyService heavyService() {
        return new HeavyService();
    }

    // プロトタイプスコープ（毎回新しいインスタンス）
    @Bean
    @Scope("prototype")
    public DataProcessor dataProcessor() {
        return new DataProcessor();
    }

    // リクエストスコープ（適切な破棄が重要）
    @Bean
    @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
    public RequestScopedBean requestScopedBean() {
        return new RequestScopedBean();
    }
}

@Component
public class ResourceHeavyBean implements DisposableBean {
    private final List<byte[]> heavyData = new ArrayList<>();

    @PreDestroy
    public void cleanup() {
        heavyData.clear();
        System.gc(); // 必要に応じてGCを促す
    }

    @Override
    public void destroy() {
        cleanup();
    }
}

@Service
public class ServiceA {
    private final ServiceB serviceB;

    // コンストラクタインジェクションで循環参照を検出可能
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Service
public class ServiceB {
    private final ServiceA serviceA;

    // コンパイル時に循環参照が検出される
    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

@Service
public class ServiceA {
    // LazyにすることでBeanの初期化時期を制御
    @Lazy
    @Autowired
    private ServiceB serviceB;

    public void processA() {
        // ServiceBの使用時に初期化
        serviceB.processB();
    }
}

@Service
public class ServiceB {
    // イベント駆動による疎結合な設計
    private final ApplicationEventPublisher eventPublisher;

    public ServiceB(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void processB() {
        eventPublisher.publishEvent(new ProcessBEvent());
    }
}

# 推奨されるJVM設定
JAVA_OPTS="\
    -Xms2g \
    -Xmx2g \
    -XX:MetaspaceSize=256m \
    -XX:MaxMetaspaceSize=512m \
    -XX:+UseG1GC \
    -XX:+HeapDumpOnOutOfMemoryError \
    -XX:HeapDumpPath=/path/to/dumps \
    -XX:+PrintGCDetails \
    -XX:+PrintGCDateStamps \
    -Xloggc:/path/to/gc.log"

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        jdbc:
          batch_size: 50
        order_inserts: true
        order_updates: true
        batch_versioned_data: true
    open-in-view: false

  cache:
    caffeine:
      spec: maximumSize=500,expireAfterWrite=30m

  tomcat:
    max-threads: 200
    min-spare-threads: 20
    max-connections: 10000
    accept-count: 100

@Configuration
public class MemoryOptimizedConfig {
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                // セッションクリーンアップインターセプター
                registry.addInterceptor(new SessionCleanupInterceptor());
            }
        };
    }

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(500)
            .expireAfterWrite(Duration.ofMinutes(30))
            .recordStats());
        return cacheManager;
    }

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(100);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

　　● キュー容量の制限

// ✓ リソースの適切なクローズ
public class ResourceManagementExample {
    // BAD: リソースがクローズされない可能性
    public void badExample() throws IOException {
        InputStream is = new FileInputStream("data.txt");
        // 処理中に例外が発生するとクローズされない
        is.read();
        is.close();
    }

    // GOOD: try-with-resourcesによる確実なクローズ
    public void goodExample() throws IOException {
        try (InputStream is = new FileInputStream("data.txt")) {
            is.read();
        }
    }
}

// ✓ コレクションの使用方法
public class CollectionManagementExample {
    // BAD: 無制限に成長する可能性
    private static final List<String> dataList = new ArrayList<>();

    // GOOD: サイズ制限付きのキャッシュ
    private static final Cache<String, String> dataCache = CacheBuilder.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build();
}

public class MemoryLeakTest {
    @Test
    public void testNoMemoryLeak() {
        // 初期メモリ使用量を記録
        long initialMemory = getUsedMemory();

        // テスト対象の処理を実行
        for (int i = 0; i < 1000; i++) {
            processSomeData();
            System.gc();  // GCを促す
        }

        // 最終メモリ使用量を確認
        long finalMemory = getUsedMemory();

        // メモリ増加が閾値以内であることを確認
        assertTrue(finalMemory - initialMemory < MEMORY_THRESHOLD);
    }

    private long getUsedMemory() {
        Runtime rt = Runtime.getRuntime();
        return rt.totalMemory() - rt.freeMemory();
    }
}

@Test
public void testResourceCleanupUnderLoad() {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    List<Future<?>> futures = new ArrayList<>();

    // 複数スレッドで同時にリソースを使用
    for (int i = 0; i < 100; i++) {
        futures.add(executor.submit(() -> {
            try (Resource resource = new Resource()) {
                resource.process();
            }
        }));
    }

    // 全てのタスクの完了を待つ
    futures.forEach(future -> {
        try {
            future.get(1, TimeUnit.MINUTES);
        } catch (Exception e) {
            fail("Resource cleanup failed");
        }
    });
}

@Component
public class MemoryMonitor {
    private static final Logger logger = LoggerFactory.getLogger(MemoryMonitor.class);

    @Scheduled(fixedRate = 300000) // 5分ごと
    public void monitorMemory() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        long usedMemory = totalMemory - freeMemory;

        // メモリ使用率を計算
        double memoryUsagePercent = ((double) usedMemory / totalMemory) * 100;

        // 警告レベルに応じてログ出力
        if (memoryUsagePercent > 90) {
            logger.error("Critical memory usage: {}%", memoryUsagePercent);
        } else if (memoryUsagePercent > 80) {
            logger.warn("High memory usage: {}%", memoryUsagePercent);
        } else {
            logger.info("Current memory usage: {}%", memoryUsagePercent);
        }
    }

    @Bean
    public HealthIndicator memoryHealthIndicator() {
        return () -> {
            Runtime runtime = Runtime.getRuntime();
            long usedMemory = runtime.totalMemory() - runtime.freeMemory();
            double memoryUsagePercent = ((double) usedMemory / runtime.totalMemory()) * 100;

            Health.Builder builder = new Health.Builder();
            if (memoryUsagePercent > 90) {
                return builder.down()
                    .withDetail("memory_usage_percent", memoryUsagePercent)
                    .build();
            }
            return builder.up()
                .withDetail("memory_usage_percent", memoryUsagePercent)
                .build();
        };
    }
}

# alerting-config.yml
alerts:
  memory:
    warning_threshold: 80
    critical_threshold: 90
    check_interval: 5m
    notification:
      slack:
        channel: "#system-alerts"
      email:
        recipients: "team@example.com"

// Grafanaダッシュボード設定例
{
  "panels": [
    {
      "title": "JVM Memory Usage",
      "type": "graph",
      "metrics": [
        "jvm_memory_used",
        "jvm_memory_max"
      ],
      "thresholds": [
        {
          "value": 80,
          "colorMode": "warning"
        },
        {
          "value": 90,
          "colorMode": "critical"
        }
      ]
    }
  ]
}

@Service
public class OptimizedBatchProcessor {
    private static final int CHUNK_SIZE = 1000;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // BAD: 全データを一度にメモリに読み込む
    public void processBatchBadExample() {
        List<Data> allData = jdbcTemplate.query(
            "SELECT * FROM large_table",
            new DataRowMapper()
        );
        // メモリを圧迫する可能性がある
        processData(allData);
    }

    // GOOD: チャンク単位での処理
    public void processBatchGoodExample() {
        int offset = 0;
        while (true) {
            List<Data> chunk = jdbcTemplate.query(
                "SELECT * FROM large_table LIMIT ? OFFSET ?",
                new Object[]{CHUNK_SIZE, offset},
                new DataRowMapper()
            );

            if (chunk.isEmpty()) {
                break;
            }

            processDataChunk(chunk);
            offset += CHUNK_SIZE;

            // 明示的なGC要求（必要な場合のみ）
            if (offset % 10000 == 0) {
                System.gc();
            }
        }
    }

    // Spring Batchを使用した実装
    @Bean
    public Step chunkStep(
            ItemReader<Data> reader,
            ItemProcessor<Data, ProcessedData> processor,
            ItemWriter<ProcessedData> writer) {
        return stepBuilderFactory.get("chunkStep")
            .<Data, ProcessedData>chunk(CHUNK_SIZE)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .faultTolerant()
            .retry(Exception.class)
            .retryLimit(3)
            .build();
    }
}

public class MemoryEfficientStructures {
    // BAD: 不必要なオブジェクト生成
    private class InefficientData {
        private String data;
        private Integer count;  // オートボクシングのオーバーヘッド
        private List<String> details = new ArrayList<>();  // 初期容量未指定
    }

    // GOOD: メモリ効率を考慮した実装
    private class EfficientData {
        private String data;
        private int count;  // プリミティブ型の使用
        private List<String> details;  // 必要時に初期化

        public List<String> getDetails() {
            if (details == null) {
                details = new ArrayList<>(16);  // 初期容量を指定
            }
            return details;
        }
    }
}

@Configuration
public class SessionConfig {
    @Bean
    public HttpSessionListener httpSessionListener() {
        return new HttpSessionListener() {
            @Override
            public void sessionCreated(HttpSessionEvent se) {
                // セッションタイムアウトを30分に設定
                se.getSession().setMaxInactiveInterval(1800);
            }

            @Override
            public void sessionDestroyed(HttpSessionEvent se) {
                // セッション破棄時のクリーンアップ
                cleanupSession(se.getSession());
            }
        };
    }
}

@Component
public class SessionCleanupScheduler {
    @Scheduled(fixedRate = 3600000) // 1時間ごと
    public void cleanupInactiveSessions() {
        // 期限切れセッションの検出と削除
    }
}

public class OptimizedSessionData implements Serializable {
    private static final long serialVersionUID = 1L;

    // 必要最小限のデータのみを保持
    @JsonIgnore // シリアライズ対象から除外
    private transient BigObject temporaryData;

    private String userId;
    private LocalDateTime lastAccess;

    // セッションサイズを制限するためのカスタムシリアライズ
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        // 大きなオブジェクトは保存しない
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        // 必要に応じて一時データを再構築
    }
}

@Configuration
public class ResourceConfig {
    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setConnectionRequestTimeout(5000);

        PoolingHttpClientConnectionManager cm = 
            new PoolingHttpClientConnectionManager();
        cm.setMaxTotal(100);
        cm.setDefaultMaxPerRoute(20);

        CloseableHttpClient httpClient = HttpClients.custom()
            .setConnectionManager(cm)
            .evictExpiredConnections()
            .evictIdleConnections(30, TimeUnit.SECONDS)
            .build();

        factory.setHttpClient(httpClient);

        return new RestTemplate(factory);
    }
}

@Configuration
public class MonitoringConfig {
    @Bean
    public MeterRegistry meterRegistry() {
        return new SimpleMeterRegistry();
    }

    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

@Service
public class MonitoredService {
    private final MeterRegistry meterRegistry;

    @Timed("service.operation.time")
    public void performOperation() {
        // 処理の実行
        meterRegistry.counter("service.operation.count").increment();
    }
}

   // メモリ監視の基本実装例
   public class MemoryMonitor {
       private static final Logger logger = LoggerFactory.getLogger(MemoryMonitor.class);

       @Scheduled(fixedRate = 300000) // 5分ごと
       public void checkMemoryHealth() {
           Runtime runtime = Runtime.getRuntime();
           long usedMemory = runtime.totalMemory() - runtime.freeMemory();
           long maxMemory = runtime.maxMemory();

           double memoryUsagePercent = (usedMemory * 100.0) / maxMemory;

           logger.info(String.format(
               "Memory Usage: %.2f%% (Used: %d MB, Max: %d MB)",
               memoryUsagePercent,
               usedMemory / (1024 * 1024),
               maxMemory / (1024 * 1024)
           ));
       }
   }