内存泄漏排查：Heap Dump + MAT + VisualVM 实战

# 每 5 秒采样一次，持续观察
jstat -gcutil <pid> 5000

# 输出示例（关键列）：
#  S0    S1    E     O     M    CCS   YGC   YGCT   FGC  FGCT    GCT
  0.0 45.2 78.3 62.1 89.4 88.7  342  5.67    2  1.23   6.90
  0.0 12.5 15.6 63.5 89.4 88.7  344  5.71    2  1.23   6.94
  0.0 12.5 67.2 64.9 89.4 88.7  344  5.71    2  1.23   6.94
# O=Old 老年代使用率  M=Metaspace  YGC/FGC=Young/Full GC 次数  GCT=GC 总耗时

# 基本命令：导出二进制格式的堆转储
jmap -dump:format=b,file=/data/dumps/heap_$(date +%Y%m%d_%H%M%S).hprof <pid>

# 如果 jmap 无响应（JVM 处于 GC 中），使用 F 参数强制 dump
jmap -F -dump:format=b,file=heap.hprof <pid>

# JDK 9+ 推荐用 jcmd 替代 jmap
jcmd <pid> GC.heap_dump /data/dumps/heap.hprof

java \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=/data/dumps/heap_%p.hprof \
  -jar app.jar

# %p 会替换为进程 PID，避免多次 OOM 覆盖同一文件
# OOM 发生时 JVM 自动执行：dump 堆 → 写入指定路径 → 然后退出

# 只看存活对象的 Top 20，按字节数排序
jmap -histo:live <pid> | head -25

# 输出示例：
#  num     #instances    #bytes  class name
#    1:       1280000  327680000  [B                      ← byte[] 327MB
#    2:        640000  204800000  com.app.CacheEntry       ← 自定义缓存 204MB
#    3:        512000  122880000  java.lang.String
#    4:         80000   51200000  java.util.HashMap$Node

Leak Suspect 1:
  One instance of "com.app.service.OrderService"
  loaded by "org.springframework.boot.loader.LaunchedURLClassLoader"
  occupies 1,234,567,890 (38.2%) bytes.

  Biggest instances:
  - java.util.concurrent.ConcurrentHashMap$Node[] → 800MB
  - com.app.cache.LocalCacheEntry[]             → 350MB
  - java.lang.String[]                          →  84MB

  Reference chain:
  java.lang.Thread "http-nio-8080-exec-1"
    → java.lang.ThreadLocal$ThreadLocalMap
      → java.lang.ThreadLocal$ThreadLocalMap$Entry[]
        → com.app.context.UserContext
          → java.util.HashMap
            → com.app.cache.LocalCacheEntry[]
              → byte[] (800MB retained)

// ===== 泄漏代码 =====
public class UserContext {
    private static final ThreadLocal<Map<String, Object>> ctx =
        ThreadLocal.withInitial(HashMap::new);

    public static void set(String key, Object value) {
        ctx.get().put(key, value);  // 只 put 不 remove
    }
}

// Filter 中设值，但忘了清理
public void doFilter(req, resp, chain) {
    UserContext.set("userId", req.getHeader("X-User-Id"));
    chain.doFilter(req, resp);  // 请求结束，ThreadLocal 中的数据没清除！
}

// ===== 修复代码 =====
public void doFilter(req, resp, chain) {
    try {
        UserContext.set("userId", req.getHeader("X-User-Id"));
        chain.doFilter(req, resp);
    } finally {
        UserContext.clear();  // ← 关键：finally 中必须 remove
    }
}

// ===== 泄漏代码：异常时 Connection 没关闭 =====
public List<Order> findOrders(Long userId) {
    Connection conn = dataSource.getConnection();
    PreparedStatement ps = conn.prepareStatement("SELECT * FROM orders WHERE uid=?");
    ps.setLong(1, userId);
    ResultSet rs = ps.executeQuery();  // 如果这里抛异常，conn 永远不会 close
    // ... 处理结果 ...
    conn.close();  // 这行在异常时不会执行！
    return orders;
}

// ===== 修复代码：try-with-resources =====
public List<Order> findOrders(Long userId) {
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement("SELECT * FROM orders WHERE uid=?")) {
        ps.setLong(1, userId);
        try (ResultSet rs = ps.executeQuery()) {
            // ... 处理结果 ...
        }
    }  // ← 自动 close，即使发生异常
    return orders;
}

// ===== 泄漏代码：HashMap 缓存无上限 =====
public class ProductCache {
    private final Map<String, Product> cache = new ConcurrentHashMap<>();

    public Product get(String id) {
        return cache.computeIfAbsent(id, this::loadFromDB);
        // 只进不出！cache 无限增长
    }
}

// ===== 修复代码：用 Caffeine 设置容量上限 + 过期策略 =====
public class ProductCache {
    private final Cache<String, Product> cache = Caffeine.newBuilder()
        .maximumSize(10_000)              // 最多 10000 条
        .expireAfterWrite(Duration.ofMinutes(30))  // 写入后 30 分钟过期
        .recordStats()                     // 开启命中率统计
        .build();

    public Product get(String id) {
        return cache.get(id, this::loadFromDB);
    }
}

# 1. 远程连接目标 JVM
#    在目标服务器启动 JMX（如果未使用 Spring Boot Actuator）
java \
  -Dcom.sun.management.jmxremote \
  -Dcom.sun.management.jmxremote.port=9010 \
  -Dcom.sun.management.jmxremote.authenticate=false \
  -Dcom.sun.management.jmxremote.ssl=false \
  -jar app.jar

# 2. VisualVM 中：File → Add JMX Connection → 输入 host:9010

# 3. Monitor 面板：观察 Heap 曲线
#    - 正常：锯齿形，GC 后回落稳定基线
#    - 泄漏：底部持续抬高，Full GC 后回落线越来越高

# 4. 确认泄漏后：Monitor → "Heap Dump" 按钮 → 保存 .hprof

# 5. 将 .hprof 文件拖入 MAT → 按第 4 站流程分析

# Prometheus + JMX Exporter 方案
# 1. 下载 jmx_prometheus_javaagent.jar
# 2. 编写 jmx-config.yml 定义采集指标
# 3. 启动时挂载 agent
java \
  -javaagent:jmx_prometheus_javaagent.jar=9404:jmx-config.yml \
  -jar app.jar

# 4. Prometheus 抓取 :9404/metrics
# 5. Grafana 导入 JVM Dashboard（模板 ID: 4701）
#    → 实时监控堆内存、GC、线程，自动告警