Java Full GC の危険性と回避策 — Stop-The-World・GC チューニング・実装設計

import java.lang.management.*;
import java.lang.ref.*;
import java.util.*;

/**
 * Full GC 回避パターン集
 *
 * === 起動 JVM オプション テンプレート ===
 *
 * [GC アルゴリズム選択]
 *   -XX:+UseG1GC                          Java 9+ デフォルト（バランス重視）
 *   -XX:+UseZGC                           低レイテンシ向け（Java 15+、STW < 1ms）
 *   -XX:+UseZGC -XX:+ZGenerational        Generational ZGC（Java 21+、効率↑）
 *
 * [G1GC チューニング — Full GC 抑制]
 *   -XX:MaxGCPauseMillis=200              目標停止時間（保証ではない）
 *   -XX:G1HeapRegionSize=16m             Humongous 閾値を 8MB に引き上げ
 *   -XX:G1NewSizePercent=30              Young 世代最小割合（デフォルト 5%）
 *   -XX:InitiatingHeapOccupancyPercent=35 Mixed GC 開始閾値を下げて Old Gen 詰まりを防ぐ
 *
 * [System.gc() 無効化]
 *   -XX:+DisableExplicitGC               System.gc() / RMI 定期 GC を無効化
 *
 * [Metaspace 上限]
 *   -XX:MaxMetaspaceSize=256m            ClassLoader リーク時の保護
 *
 * [GC ログ・障害対応]
 *   -Xlog:gc*:file=gc.log:time,uptime,level,tags
 *   -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heap.hprof
 */
public class FullGcPreventionPatterns {

    // ================================================================
    // Part 1: ヒープ監視 — ManagementFactory で Full GC の予兆を捕捉
    // ================================================================
    record HeapSnapshot(long usedMb, long maxMb, double usagePct,
                        long gcCount, long gcTimeMs) {
        String level() {
            if (usagePct > 90) return "CRITICAL";
            if (usagePct > 80) return "WARNING";
            return "OK";
        }
    }

    static HeapSnapshot captureHeap() {
        var mem = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
        long gcCount = 0, gcTimeMs = 0;
        for (var gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            gcCount  += gc.getCollectionCount();
            gcTimeMs += gc.getCollectionTime();
        }
        return new HeapSnapshot(
            mem.getUsed() >> 20, mem.getMax() >> 20,
            (double) mem.getUsed() / mem.getMax() * 100,
            gcCount, gcTimeMs);
    }

    // ================================================================
    // Part 2: 静的コレクションのメモリリーク対策
    //         上限なし static キャッシュは Full GC の最多原因の一つ
    // ================================================================

    // BAD: 上限なし static HashMap → Old Gen に蓄積し続けて Full GC を誘発
    // private static final Map<String, byte[]> CACHE = new HashMap<>();

    // GOOD: SoftReference + LRU でメモリ逼迫時に自動解放
    static class BoundedSoftCache {
        private final Map<String, SoftReference<byte[]>> inner;

        BoundedSoftCache(final int maxSize) {
            this.inner = new LinkedHashMap<String, SoftReference<byte[]>>(
                    16, 0.75f, true) {
                @Override protected boolean removeEldestEntry(
                        Map.Entry<String, SoftReference<byte[]>> eldest) {
                    return size() > maxSize;
                }
            };
        }

        public synchronized void put(String key, byte[] value) {
            inner.put(key, new SoftReference<>(value));
        }

        public synchronized byte[] get(String key) {
            SoftReference<byte[]> ref = inner.get(key);
            if (ref == null) return null;
            byte[] value = ref.get(); // OOM 直前に GC されると null
            if (value == null) inner.remove(key); // ゴーストエントリを除去
            return value;
        }
    }

    // ================================================================
    // Part 3: ThreadLocal リーク対策
    //         Servlet / スレッドプール環境では remove() 漏れが
    //         実質的なメモリリークになる
    // ================================================================
    static final ThreadLocal<String> REQUEST_ID = new ThreadLocal<>();

    // BAD: スレッドが再利用されるたびに前のリクエストの値が残留
    // void badProcess(String id) { REQUEST_ID.set(id); /* ... */ }

    // GOOD: try-finally で必ず remove()
    static void processWithContext(String requestId, Runnable task) {
        REQUEST_ID.set(requestId);
        try {
            task.run();
        } finally {
            REQUEST_ID.remove(); // スレッドプール返却前に必ずクリア
        }
    }

    // ================================================================
    // Part 4: Humongous オブジェクト対策（G1GC）
    //         ストリーミング処理でバッファを使い回し、
    //         大きな byte[] の頻繁な生成を避ける
    // ================================================================
    static void streamCopy(java.io.InputStream in, java.io.OutputStream out)
            throws java.io.IOException {
        byte[] buf = new byte[64 * 1024]; // 64KB バッファを使い回す
        int len;
        while ((len = in.read(buf)) != -1) {
            out.write(buf, 0, len);
        }
        // BAD 例: while (...) { byte[] chunk = new byte[1MB]; ... }
        // 1MB の new が繰り返されると G1GC の Humongous 領域が消費される
    }

    // ================================================================
    // Part 5: WeakHashMap — キーが GC されたらエントリも自動消滅
    // ================================================================
    static class WeakKeyCache {
        private final WeakHashMap<Object, String> inner = new WeakHashMap<>();
        public void put(Object key, String value) { inner.put(key, value); }
        public String get(Object key) { return inner.get(key); }
        public int size() { return inner.size(); }
    }

    // ================================================================
    // Part 6: 短命オブジェクト設計
    //         スコープを狭く保ち Young GC で完結させる
    // ================================================================
    static long processData(int count) {
        long sum = 0;
        for (int i = 0; i < count; i++) {
            String temp = "item-" + i; // メソッド内で完結 → Young GC で回収
            sum += temp.length();
        }
        return sum; // temp への参照はここで消滅 → Old Gen への昇格なし
    }

    public static void main(String[] args) throws InterruptedException {
        // ヒープ監視
        System.out.println("=== ヒープ状態確認 ===");
        var snap = captureHeap();
        System.out.printf("[%s] %.1f%% (%d/%d MB) | GC回数=%d 累計=%dms%n",
            snap.level(), snap.usagePct(), snap.usedMb(), snap.maxMb(),
            snap.gcCount(), snap.gcTimeMs());
        if (!"OK".equals(snap.level())) {
            System.err.println("→ Full GC の予兆。-XX:+HeapDumpOnOutOfMemoryError でダンプ取得を推奨");
        }

        // ThreadLocal 正常パターン
        System.out.println("\n=== ThreadLocal リーク対策 ===");
        processWithContext("req-001",
            () -> System.out.println("処理中 requestId=" + REQUEST_ID.get()));
        System.out.println("remove後: " + REQUEST_ID.get()); // null

        // WeakHashMap の挙動
        System.out.println("\n=== WeakHashMap キャッシュ ===");
        var weakCache = new WeakKeyCache();
        byte[] key = new byte[1024];
        weakCache.put(key, "関連データ");
        System.out.println("GC前 size=" + weakCache.size()); // 1
        key = null; // 強参照を解放
        System.gc(); Thread.sleep(100);
        System.out.println("GC後 size=" + weakCache.size()); // 0 の可能性

        // SoftReference キャッシュ
        System.out.println("\n=== SoftReference キャッシュ ===");
        var softCache = new BoundedSoftCache(100);
        softCache.put("img-001", new byte[10 * 1024]);
        byte[] hit = softCache.get("img-001");
        System.out.println("ヒット: " + (hit != null ? hit.length + " bytes" : "GC 済み"));

        // 短命オブジェクト処理
        System.out.println("\n=== 短命オブジェクト設計 ===");
        long result = processData(100_000);
        System.out.println("結果: " + result);
        var after = captureHeap();
        System.out.printf("処理後ヒープ: [%s] %.1f%%%n", after.level(), after.usagePct());
    }
}