JVM 运行时数据区与对象内存布局

// 演示 Metaspace OOM
// JVM 参数：-XX:MaxMetaspaceSize=32m
public class MetaspaceOOM {
    public static void main(String[] args) {
        int count = 0;
        try {
            while (true) {
                // 使用 CGLib 或 Javassist 不断生成新类
                // 这里用 ClassLoader 模拟
                ClassLoader loader = new ClassLoader() {
                    @Override
                    protected Class<?> findClass(String name) {
                        byte[] code = generateClassBytes(name);
                        return defineClass(name, code, 0, code.length);
                    }
                };
                loader.loadClass("Generated" + count++);
            }
        } catch (Throwable e) {
            System.out.println("Created " + count + " classes before OOM");
            e.printStackTrace();
        }
    }

    private static byte[] generateClassBytes(String name) {
        // 简化：实际应使用 ASM/ByteBuddy 生成字节码
        return new byte[0];
    }
}

// 演示 StackOverflowError
public class StackOverflowDemo {
    private static int depth = 0;

    public static void recursive() {
        depth++;
        recursive();
    }

    public static void main(String[] args) {
        try {
            recursive();
        } catch (StackOverflowError e) {
            System.out.println("Stack depth: " + depth);
            // 默认栈大小（-Xss512k）下约 11000 层
            // -Xss1m 下约 23000 层
        }
    }
}

// 用 javap -v 查看 PC 与字节码行号对应
public class PCExample {
    public int add(int a, int b) {
        int c = a + b;
        return c;
    }
}
// 字节码：
//  0: iload_1
//  1: iload_2
//  2: iadd
//  3: istore_3
//  4: iload_3
//  5: ireturn

import java.nio.ByteBuffer;

public class DirectMemoryDemo {
    public static void main(String[] args) {
        // 堆内 Buffer：分配在 JVM 堆，受 GC 管理
        ByteBuffer heapBuffer = ByteBuffer.allocate(1024);

        // 直接 Buffer：分配在 native 内存，不受 -Xmx 限制
        // 受 -XX:MaxDirectMemorySize 控制
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024 * 1024);

        // 直接内存的释放由 Cleaner（PhantomReference + ReferenceQueue）触发
        // 不保证及时释放，可能导致 OOM: Direct buffer memory
    }
}

# 直接内存相关参数
-XX:MaxDirectMemorySize=256m      # 最大直接内存
-Djdk.nio.maxCachedBufferSize=0   # 禁用 Buffer 缓存（避免线程本地缓存泄漏）

# 默认开启，堆 < 32GB 时自动启用
-XX:+UseCompressedOops

# 关闭（堆 ≥ 32GB 时强制关闭）
-XX:-UseCompressedOops

// 演示对象大小（需 JOL 工具）
// 添加依赖：org.openjdk.jol:jol-core:0.17
import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.info.GraphLayout;

public class ObjectSizeDemo {
    public static void main(String[] args) {
        // 空对象：16 字节（开启压缩指针）
        // - 12 字节头（8 Mark + 4 Class Pointer）
        // - 4 字节对齐填充
        Object obj = new Object();
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());

        // 含两个 long 字段的对象：24 字节
        // - 12 字节头
        // - 16 字节实例数据（两个 long）
        // - 不需要填充
        class TwoLongs {
            long a, b;
        }
        System.out.println(ClassLayout.parseInstance(new TwoLongs()).toPrintable());

        // 数组：16 + 元素大小
        int[] ints = new int[10];
        System.out.println(ClassLayout.parseInstance(ints).toPrintable());
        // 16 字节头（12 对象头 + 4 数组长度）+ 40 字节（10×4）= 56 字节
    }
}

// 字段重排序优化
class FieldOrdering {
    // 声明顺序
    boolean b;   // 1 字节
    long l;      // 8 字节
    int i;       // 4 字节
    short s;     // 2 字节
    char c;      // 2 字节

    // JVM 实际布局（父类在前，相同宽度相邻）
    // [header 12] [long 8] [int 4] [char 2] [short 2] [boolean 1] [padding 3]
    // 总计：32 字节
}

# TLAB 相关参数
-XX:+UseTLAB                 # 默认开启
-XX:TLABSize=64k             # TLAB 大小
-XX:MinTLABSize=1k
-XX:TLABWasteTargetPercent=1 # TLAB 占 Eden 的比例
-XX:+ResizeTLAB              # 动态调整 TLAB 大小
-XX:+PrintTLAB               # 打印 TLAB 统计

-XX:PretenureSizeThreshold=1m   # 大于此阈值的对象直接在老年代分配
                                 # 仅对 Serial/ParNew 生效

-XX:MaxTenuringThreshold=15       # 最大晋升年龄
-XX:InitialTenuringThreshold=7    # 初始晋升年龄
-XX:+PrintTenuringDistribution    # 打印年龄分布
-XX:+UseAdaptiveSizePolicy        # 自适应调整（可能忽略 MaxTenuringThreshold）

-XX:MetaspaceSize=256m        # 触发 Full GC 的阈值
-XX:MaxMetaspaceSize=512m     # 最大元空间
-XX:MinMetaspaceFreeRatio=40  # GC 后最小空闲比例
-XX:MaxMetaspaceFreeRatio=70  # GC 后最大空闲比例

# Python 使用引用计数 + 标记清除（处理循环引用）
a = []
b = [a]
a.append(b)
del a, b  # 两个对象的引用计数均为 1，但已不可达

标记阶段：从 GC Roots 遍历，标记所有存活对象
清除阶段：清除未标记的对象

优点：实现简单
缺点：内存碎片多，分配大对象时可能触发 Full GC

将堆分为两半，每次只使用一半
GC 时将存活对象复制到另一半
然后清空当前半区

优点：无碎片，分配快
缺点：可用内存减半

标记阶段：标记存活对象
整理阶段：将存活对象向一端移动，清理边界外内存

优点：无碎片
缺点：移动对象开销大，需更新所有引用

-XX:+PrintSafepointStatistics       # 打印安全点统计
-XX:PrintSafepointStatisticsCount=1
-XX:+SafepointTimeout               # 安全点超时报警
-XX:SafepointTimeoutDelay=1000      # 超时阈值（ms）

// 这个循环可能长时间不进入安全点
public void longLoop() {
    long start = System.nanoTime();
    // counted loop（int 计数）会被 JIT 优化，不进入安全点
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        // 长时间运行，可能阻塞其他线程的 GC
    }
    // 改用 long 计数避免优化
    // for (long i = 0; i < Long.MAX_VALUE; i++) { }
}

# G1 关键参数
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200        # 目标最大停顿时间（软目标）
-XX:G1HeapRegionSize=16m        # Region 大小（1-32MB，自动选择）
-XX:InitiatingHeapOccupancyPercent=45  # 触发并发标记的堆占用阈值
-XX:G1NewSizePercent=5          # 新生代最小比例
-XX:G1MaxNewSizePercent=60      # 新生代最大比例
-XX:G1MixedGCCountTarget=8      # 混合回收次数目标
-XX:G1MixedGCLiveThresholdPercent=85  # Region 存活率高于此值不回收
-XX:ConcGCThreads=4             # 并发标记线程数
-XX:ParallelGCThreads=8         # STW 阶段并行线程数

// G1 SATB 写屏障（伪代码）
void satbWriteBarrier(Object* field, Object* newValue) {
    Object* oldValue = *field;
    if (oldValue != null) {
        satbQueue.enqueue(oldValue);  // 加入 SATB 队列
    }
    *field = newValue;
}

# ZGC 参数（Java 21+）
-XX:+UseZGC
-XX:+ZGenerational           # 启用分代 ZGC（Java 21+，默认）
-XX:SoftMaxHeapSize=4g       # 软上限，ZGC 试图保持在此之下
-XX:ZAllocationSpikeTolerance=2  # 分配尖峰容忍度
-XX:ConcGCThreads=4          # 并发线程数
-XX:ParallelGCThreads=8      # STW 线程数
-XX:+ZProactive              # 主动 GC（即使堆未满也回收，避免紧急 GC）

# Shenandoah 参数
-XX:+UseShenandoahGC
-XX:ShenandoahGCHeuristics=adaptive  # 自适应（默认）
-XX:ShenandoahGarbageThreshold=20    # Region 垃圾占比阈值
-XX:ShenandoahAllocationThreshold=20 # Region 触发 GC 的阈值

// 使用 JMH 基准测试对比收集器吞吐
// 需要 org.openjdk.jmh:jmh-core
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Thread)
public class GCBenchmark {

    @Param({"g1", "zgc", "shenandoah"})
    private String gc;

    private List<byte[]> cache = new ArrayList<>();

    @Setup
    public void setup() {
        // 预热缓存
        for (int i = 0; i < 1000; i++) {
            cache.add(new byte[1024]);
        }
    }

    @Benchmark
    public void allocateAndRelease() {
        // 分配 100KB，模拟短期对象
        byte[] data = new byte[100 * 1024];
        // data 离开作用域后可回收
    }

    public static void main(String[] args) throws RunnerException {
        for (String gc : new String[]{"g1", "zgc", "shenandoah"}) {
            Options opt = new OptionsBuilder()
                .include(GCBenchmark.class.getSimpleName())
                .param("gc", gc)
                .jvmArgs("-XX:+Use" + (gc.equals("g1") ? "G1GC" :
                          gc.equals("zgc") ? "ZGC" : "ShenandoahGC"),
                         "-Xmx4g", "-Xms4g")
                .forks(1)
                .build();
            new Runner(opt).run();
        }
    }
}

# 错误配置
docker run -m 2g java -Xmx2g -jar app.jar

# 正确配置（保留 native 内存空间）
docker run -m 2g java \
  -XX:MaxRAMPercentage=70 \
  -XX:MaxMetaspaceSize=256m \
  -XX:MaxDirectMemorySize=256m \
  -Xss512k \
  -jar app.jar

# 错误：在 32 核机器上设置过多 GC 线程
-XX:ParallelGCThreads=32

# GC 线程过多会导致：
# 1. GC 线程间同步开销大
# 2. 抢占应用线程 CPU
# 3. 频繁上下文切换

# 正确：通常为 CPU 核数的 5/8
-XX:ParallelGCThreads=20  # 32 核机器

// 业务代码调用 System.gc()，触发 Full GC
System.gc();  // 性能杀手

// 解决：禁用显式 GC
// -XX:+DisableExplicitGC
// 或 -XX:+ExplicitGCInvokesConcurrent（G1 下转为并发 GC）

// 错误：未释放 DirectByteBuffer
public void leak() {
    while (true) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
        // buffer 离开作用域后由 Cleaner 异步释放
        // 但若引用被长期持有，导致 OOM: Direct buffer memory
    }
}

// 正确：手动释放或使用 try-with-resources
public void safe() {
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
    try {
        // 使用 buffer
    } finally {
        // Java 9+ 提供了 Cleaner API
        // 或显式调用 sun.misc.Cleaner（不推荐）
    }
}

// 错误：ThreadLocal 在线程池中不清理
private static final ThreadLocal<byte[]> CACHE = ThreadLocal.withInitial(() -> new byte[1024 * 1024]);

public void process() {
    byte[] data = CACHE.get();
    // 使用后未 remove
}

// 线程池中的线程长期持有 ThreadLocal，导致内存泄漏
// 解决：使用后必 remove
public void process() {
    try {
        byte[] data = CACHE.get();
        // 使用 data
    } finally {
        CACHE.remove();  // 必须清理
    }
}

// 错误：finalize 慢导致对象堆积
class SlowFinalizer {
    @Override
    protected void finalize() throws Throwable {
        Thread.sleep(1000);  // 慢
    }
}

// 大量 SlowFinalizer 对象创建时，finalize 队列堆积，老年代 OOM
// Java 9+ 标记 finalize 为 deprecated，Java 18+ 标记 forRemoval

// 替代方案：Cleaner（Java 9+）
class Resource implements AutoCloseable {
    private static final Cleaner cleaner = Cleaner.create();
    private final Cleaner.Cleanable cleanable;

    public Resource() {
        cleanable = cleaner.register(this, () -> {
            // 清理逻辑
        });
    }

    @Override
    public void close() {
        cleanable.clean();  // 显式清理
    }
}

// 错误：大量 intern 导致 PermGen/Metaspace OOM
for (int i = 0; i < 10000000; i++) {
    String s = ("prefix" + i).intern();
}

// intern 在 JDK 6+ 移到堆，但仍可能 OOM
// Java 7+ intern 在堆，但仍有开销
// 建议：避免 intern，使用 ConcurrentHashMap 自行缓存

# 监控 native 内存（Java 23+ NMT 增强）
-XX:NativeMemoryTracking=summary
jcmd <pid> VM.native_memory summary

# 监控直接内存
jcmd <pid> VM.native_memory baseline
jcmd <pid> VM.native_memory detail.diff

# Java 9+ 统一日志
-Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=100m

# 关键日志标签
-Xlog:gc*                       # GC 全部
-Xlog:gc+heap=debug             # 堆变化
-Xlog:gc+age=trace              # 对象年龄
-Xlog:safepoint                 # 安全点
-Xlog:gc+ergo*=debug            # 自适应决策

# CMS 触发 Concurrent Mode Failure 时退化为 Serial Old
# 现象：偶发 10s+ 的 STW
# 原因：老年代增长过快，CMS 并发跟不上

# 解决：
# 1. 降低 -XX:CMSInitiatingOccupancyFraction=70（提前触发）
# 2. 增大 -XX:CMSTriggerRatio=80
# 3. 升级到 G1 或 ZGC

# 通用 4GB 堆 + G1 收集器
JAVA_OPTS="
  # 堆配置
  -Xms4g -Xmx4g
  -XX:MaxRAMPercentage=70.0

  # 元空间
  -XX:MetaspaceSize=256m
  -XX:MaxMetaspaceSize=512m

  # 直接内存
  -XX:MaxDirectMemorySize=512m

  # 线程栈
  -Xss512k

  # G1 收集器
  -XX:+UseG1GC
  -XX:MaxGCPauseMillis=200
  -XX:G1HeapRegionSize=16m
  -XX:InitiatingHeapOccupancyPercent=45
  -XX:G1ReservePercent=20

  # JIT
  -XX:+TieredCompilation
  -XX:CICompilerCount=4

  # OOM 处理
  -XX:+HeapDumpOnOutOfMemoryError
  -XX:HeapDumpPath=/var/log/app/heapdump
  -XX:+ExitOnOutOfMemoryError
  -XX:+CrashOnOutOfMemoryError

  # GC 日志（Java 9+ 统一日志）
  -Xlog:gc*:file=/var/log/app/gc.log:time,uptime,level,tags:filecount=10,filesize=100m

  # NMT（Native Memory Tracking）
  -XX:NativeMemoryTracking=summary

  # 异常处理
  -XX:+DisableExplicitGC
  -XX:+UseContainerSupport
  -XX:+UseStringDeduplication

  # 故障诊断
  -XX:+UnlockDiagnosticVMOptions
  -XX:+PrintCommandLineFlags
"

FROM eclipse-temurin:21-jre-alpine

# 设置容器资源限制
ENV JAVA_OPTS="
  -XX:MaxRAMPercentage=70.0
  -XX:InitialRAMPercentage=50.0
  -XX:MinRAMPercentage=25.0
  -XX:MaxMetaspaceSize=256m
  -XX:MaxDirectMemorySize=256m
  -XX:+UseZGC
  -XX:+ZGenerational
  -XX:+HeapDumpOnOutOfMemoryError
  -XX:HeapDumpPath=/tmp/heapdump
  -Xlog:gc*:file=/tmp/gc.log:time,uptime,level,tags:filecount=5,filesize=50m
  -XX:NativeMemoryTracking=summary
  -XX:+UseContainerSupport
  -XX:+ExitOnOutOfMemoryError
"

COPY target/app.jar /app/app.jar
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app/app.jar"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app
spec:
  template:
    spec:
      containers:
      - name: app
        image: registry.example.com/java-app:1.0.0
        resources:
          requests:
            memory: "2Gi"
            cpu: "1"
          limits:
            memory: "4Gi"
            cpu: "2"
        env:
        - name: JAVA_OPTS
          value: >
            -XX:MaxRAMPercentage=70.0
            -XX:+UseZGC
            -XX:+ZGenerational
            -XX:SoftMaxHeapSize=2g
            -XX:MaxMetaspaceSize=256m
            -XX:MaxDirectMemorySize=256m
            -XX:+HeapDumpOnOutOfMemoryError
            -XX:HeapDumpPath=/dump
            -Xlog:gc*:file=/log/gc.log:time,uptime,level,tags:filecount=10,filesize=100m
            -XX:NativeMemoryTracking=summary
            -XX:+ExitOnOutOfMemoryError
        volumeMounts:
        - name: heap-dump
          mountPath: /dump
        - name: gc-log
          mountPath: /log
      volumes:
      - name: heap-dump
        emptyDir: {}
      - name: gc-log
        emptyDir: {}

// 使用 ManagementFactory 监控
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.GarbageCollectorMXBean;

public class JVMMonitor {

    public static void printMemoryStats() {
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();

        MemoryUsage heap = memoryMXBean.getHeapMemoryUsage();
        MemoryUsage nonHeap = memoryMXBean.getNonHeapMemoryUsage();

        System.out.println("=== Heap ===");
        System.out.printf("Used: %d MB%n", heap.getUsed() / 1024 / 1024);
        System.out.printf("Committed: %d MB%n", heap.getCommitted() / 1024 / 1024);
        System.out.printf("Max: %d MB%n", heap.getMax() / 1024 / 1024);

        System.out.println("=== Non-Heap ===");
        System.out.printf("Used: %d MB%n", nonHeap.getUsed() / 1024 / 1024);
        System.out.printf("Committed: %d MB%n", nonHeap.getCommitted() / 1024 / 1024);

        System.out.println("=== GC ===");
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.printf("%s: count=%d, time=%dms%n",
                gc.getName(), gc.getCollectionCount(), gc.getCollectionTime());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        while (true) {
            printMemoryStats();
            Thread.sleep(5000);
        }
    }
}

# 启动时启用 JFR
java -XX:StartFlightRecording=duration=60s,filename=/tmp/app.jfr,settings=profile -jar app.jar

# 运行中启动 JFR
jcmd <pid> JFR.start duration=5m filename=/tmp/app.jfr settings=profile

# 查看 JFR 配置
jcmd <pid> JFR.check
jcmd <pid> JFR.dump filename=/tmp/dump.jfr

# 分析 JFR（使用 JDK Mission Control 或命令行）
jfr print --events jdk.GCPhasePause /tmp/app.jfr
jfr print --events jdk.GCPhasePause,jdk.JavaMonitorWait /tmp/app.jfr

# 查看 JVM 进程
jcmd -l
jps -l

# 查看堆信息
jcmd <pid> GC.heap_info

# 生成 heap dump
jcmd <pid> GC.heap_dump /tmp/heap.hprof

# 查看 GC 概要
jcmd <pid> GC.class_histogram

# 查看线程
jcmd <pid> Thread.print

# 查看 VM 信息
jcmd <pid> VM.info
jcmd <pid> VM.flags
jcmd <pid> VM.system_properties

# 查看本机内存
jcmd <pid> VM.native_memory summary

# 查看 JFR
jcmd <pid> JFR.check

# GC 概要（每 1s 输出一次，共 10 次）
jstat -gcutil <pid> 1000 10

# 输出：
#   S0     S1     E      O      M     CCS    YGC   YGCT   FGC  FGCT   GCT
#   0.00  45.23  67.89  34.56  95.12  92.34   23   0.234    2  0.456  0.690

# 字段含义：
#   S0/S1: Survivor 0/1 占比
#   E: Eden 占比
#   O: Old 占比
#   M: Metaspace 占比
#   YGC/YGCT: Young GC 次数/总时间
#   FGC/FGCT: Full GC 次数/总时间

# 类加载统计
jstat -class <pid>

# 编译统计
jstat -compiler <pid>

# 堆容量与使用
jstat -gccapacity <pid>

# 生成 heap dump
jmap -dump:format=b,file=/tmp/heap.hprof <pid>
jcmd <pid> GC.heap_dump /tmp/heap.hprof

# 自动 OOM 时生成
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/

// OQL 示例：查找所有大于 1MB 的 byte[]
SELECT * FROM byte[] s WHERE s.@retainedHeapSize > 1048576

// 查找所有 HashMap 实例
SELECT * FROM java.util.HashMap

// 查找特定类的实例
SELECT * FROM com.example.User WHERE @retainedHeapSize > 1024

# 1. 查看 GC 日志
tail -f /var/log/app/gc.log
# 发现：老年代占用 95%，频繁 Full GC，每次 STW 800ms

# 2. 生成 heap dump
jcmd <pid> GC.heap_dump /tmp/heap.hprof

# 3. 用 MAT 分析
# Dominator Tree 显示：
# java.util.concurrent.LinkedBlockingQueue 占 2.5GB（堆 4GB）
# 内部节点为订单对象

# 4. 定位代码
# 发现线程池拒绝策略为 AbortPolicy，但队列无界
# ExecutorService executor = new ThreadPoolExecutor(
#     10, 10, 0L, TimeUnit.MILLISECONDS,
#     new LinkedBlockingQueue<>());  // 无界队列！

// 改用有界队列
ExecutorService executor = new ThreadPoolExecutor(
    20,                              // 核心线程数
    100,                             // 最大线程数
    60L, TimeUnit.SECONDS,           // 空闲时间
    new ArrayBlockingQueue<>(1000),  // 有界队列
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略：调用者执行
);

// 配合 Sentinel/Hystrix 限流
@SentinelResource(value = "createOrder", blockHandler = "blockHandler")
public Order createOrder(OrderRequest req) {
    return executor.submit(() -> processOrder(req)).get(5, TimeUnit.SECONDS);
}

# 1. 查看元空间
jstat -gcmetacapacity <pid>
# MC: 512MB（MaxMetaspaceSize）, CCSC: 100MB

# 2. 查看类加载器
jcmd <pid> VM.classloader_stats
# 发现 10000+ 个 ClassLoader 实例

# 3. 用 MAT 分析
# Histogram 显示：
# org.codehaus.groovy.runtime.handlers.GroovyClassLoaderWrapper 占大量
# 每次执行 Groovy 脚本都创建新 ClassLoader

# 4. 定位代码
# 规则引擎使用 Groovy 动态执行脚本，未缓存脚本

// 缓存脚本编译结果
public class GroovyScriptCache {
    private final Map<String, Class<?>> cache = new ConcurrentHashMap<>();

    public Class<?> compile(String script) {
        return cache.computeIfAbsent(script, key -> {
            GroovyClassLoader loader = new GroovyClassLoader();
            return loader.parseClass(key);
        });
    }

    public Object execute(String script, Map<String, Object> bindings) {
        Class<?> clazz = compile(script);
        try {
            Binding binding = new Binding();
            bindings.forEach(binding::setVariable);
            return InvokerHelper.createScript(clazz, binding).run();
        } catch (Exception e) {
            throw new RuntimeException("Script execution failed", e);
        }
    }
}

# 1. 生成 heap dump
jcmd <pid> GC.heap_dump /tmp/heap.hprof

# 2. MAT 分析
# Leak Suspects Report：
# java.lang.ThreadLocal$ThreadLocalMap 占 3GB
# 内部 Entry[] 持有大量 UserContext 对象

# 3. 定位代码
# 鉴权过滤器使用 ThreadLocal 存储用户上下文，未清理
# public class AuthFilter {
#     private static ThreadLocal<UserContext> ctx = new ThreadLocal<>();
#     public void doFilter() {
#         ctx.set(loadUser());
#         chain.doFilter();
#         // 未 ctx.remove()！
#     }
# }

public class AuthFilter {
    private static final ThreadLocal<UserContext> ctx = new ThreadLocal<>();

    public void doFilter(Request req, Response res, FilterChain chain) {
        try {
            ctx.set(loadUser(req));
            chain.doFilter(req, res);
        } finally {
            ctx.remove();  // 必须清理
        }
    }

    public static UserContext current() {
        UserContext context = ctx.get();
        if (context == null) {
            throw new IllegalStateException("No user context");
        }
        return context;
    }
}

-XX:+UseG1GC -Xmx64g -Xms64g -XX:MaxGCPauseMillis=200
# P99: 200ms（不满足）

-XX:+UseZGC -XX:+ZGenerational -Xmx64g -Xms64g -XX:SoftMaxHeapSize=48g
# P99: 5ms（满足）
# 吞吐降低 8%（可接受）

# K8s limit 2GB
resources:
  limits:
    memory: "2Gi"

# JVM 参数
JAVA_OPTS="-Xmx2g -XX:MaxMetaspaceSize=512m"
# JVM 堆 2GB + Metaspace 512MB + 线程栈 + 直接内存 + JVM 自身 > 2GB

# K8s limit 2GB
resources:
  limits:
    memory: "2Gi"

# JVM 参数（按比例分配）
JAVA_OPTS="
  -XX:MaxRAMPercentage=60.0
  -XX:MaxMetaspaceSize=256m
  -XX:MaxDirectMemorySize=256m
  -Xss512k
  -XX:+UseContainerSupport
"
# 堆: 1.2GB
# Metaspace: 256MB
# 直接内存: 256MB
# 线程栈（200 线程 × 512KB）: 100MB
# JVM 自身: 100MB
# 总计: ~1.9GB < 2GB

# 1. 启用 NMT
-XX:NativeMemoryTracking=summary

# 2. 监控 native 内存
jcmd <pid> VM.native_memory summary
# Total: reserved=5GB, committed=3.5GB
# - Java Heap: 2GB
# - Class: 256MB
# - Thread: 100MB
# - Code: 200MB
# - GC: 800MB    ← 异常
# - Internal: 150MB

# 3. 进一步分析 GC 内部
jcmd <pid> VM.native_memory detail
# 发现 G1 的 Card Table 占 800MB，且持续增长

# 4. 定位代码
# 业务使用大量短生命周期的 HashMap，频繁触发 card table 扩容

# 改用 ZGC（无 Card Table）
-XX:+UseZGC -XX:+ZGenerational

# 或限制 G1 的 Card Table
# G1 没有直接参数，但优化代码减少跨代引用

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadLocalLeak {

    // 会有泄漏的版本
    static class Leaky {
        private static final ThreadLocal<byte[]> CACHE = ThreadLocal.withInitial(() -> new byte[1024 * 1024]);

        public void process() {
            byte[] data = CACHE.get();
            // 使用 data
            // 未 remove，线程池中的线程持有 CACHE
        }
    }

    // 修复后的版本
    static class Fixed {
        private static final ThreadLocal<byte[]> CACHE = ThreadLocal.withInitial(() -> new byte[1024 * 1024]);

        public void process() {
            try {
                byte[] data = CACHE.get();
                // 使用 data
            } finally {
                CACHE.remove();  // 关键：必须清理
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(10);

        // 模拟泄漏（运行一段时间后 OOM）
        // for (int i = 0; i < 100000; i++) {
        //     pool.submit(() -> new Leaky().process());
        // }

        // 修复版
        for (int i = 0; i < 100000; i++) {
            pool.submit(() -> new Fixed().process());
        }

        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.MINUTES);
        System.out.println("Done");
    }
}

public class VolatileDemo {
    // 不加 volatile 可能死循环
    // private static boolean stop = false;

    // 加 volatile 保证可见性
    private static volatile boolean stop = false;

    public static void main(String[] args) throws InterruptedException {
        Thread reader = new Thread(() -> {
            int i = 0;
            while (!stop) {
                i++;  // 防止 JIT 优化为空循环
            }
            System.out.println("Reader stopped at i=" + i);
        });
        reader.start();

        Thread.sleep(100);
        stop = true;
        System.out.println("Main set stop=true");
        reader.join();
    }
}

public class Cache {
    private static final Map<String, Object> CACHE = new HashMap<>();

    public static Object get(String key) {
        Object value = CACHE.get(key);
        if (value == null) {
            value = loadFromDB(key);
            CACHE.put(key, value);
        }
        return value;
    }

    private static Object loadFromDB(String key) {
        // 模拟 DB 加载
        return new byte[1024];
    }
}

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

public class FixedCache {
    // 方案 1：LRU 缓存（线程安全）
    private static final int MAX_SIZE = 10000;
    private static final Map<String, Object> CACHE = new LinkedHashMap<String, Object>(16, 0.75f, true) {
        @Override
        protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
            return size() > MAX_SIZE;
        }
    };
    private static final ReentrantLock lock = new ReentrantLock();

    public static Object get(String key) {
        lock.lock();
        try {
            Object value = CACHE.get(key);
            if (value == null) {
                value = loadFromDB(key);
                CACHE.put(key, value);
            }
            return value;
        } finally {
            lock.unlock();
        }
    }

    // 方案 2：使用 Caffeine（推荐）
    /*
    private static final com.github.benmanes.caffeine.cache.Cache<String, Object> CACHE =
        com.github.benmanes.caffeine.cache.Caffeine.newBuilder()
            .maximumSize(10000)
            .expireAfterWrite(10, java.util.concurrent.TimeUnit.MINUTES)
            .build();

    public static Object get(String key) {
        return CACHE.get(key, k -> loadFromDB(k));
    }
    */

    private static Object loadFromDB(String key) {
        return new byte[1024];
    }
}