JVM深入理解¶

// 类加载器层级
// Bootstrap ClassLoader   ← 加载 jre/lib 核心类库（C++实现，Java中表现为null）
//       ↑
// Platform ClassLoader    ← 加载平台模块类库（Java 9+，替代原Extension ClassLoader）
//       ↑
// Application ClassLoader ← 加载 classpath 下的用户类（默认类加载器）
//       ↑
// Custom ClassLoader      ← 用户自定义

// 双亲委派流程：
// 1. 收到类加载请求 → 先委派给父加载器
// 2. 父加载器无法加载 → 才由自身尝试加载
// 优点：保证核心类安全（防止用户篡改java.lang.String等）

// ClassLoader.loadClass() 源码核心逻辑
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查是否已加载
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                // 2. 委派给父加载器
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父加载器无法加载
            }
            if (c == null) {
                // 3. 自身尝试加载
                c = findClass(name);
            }
        }
        return c;
    }
}

import java.io.*;
import java.nio.file.*;

/**
 * 自定义类加载器 — 加载指定目录下的.class文件
 * 典型应用：热部署、加密类加载、模块隔离（如Tomcat）
 */
public class CustomClassLoader extends ClassLoader {

    private final String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String fileName = classPath + File.separator
                + name.replace('.', File.separatorChar) + ".class";
            byte[] data = Files.readAllBytes(Path.of(fileName));
            return defineClass(name, data, 0, data.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("无法加载类: " + name, e);
        }
    }

    public static void main(String[] args) throws Exception {
        CustomClassLoader loader = new CustomClassLoader("/opt/classes");
        Class<?> clazz = loader.loadClass("com.example.MyPlugin");
        Object instance = clazz.getDeclaredConstructor().newInstance();
        System.out.println("类加载器: " + clazz.getClassLoader());
        // 输出: 类加载器: com.example.CustomClassLoader@...
    }
}

// ==================== 程序计数器 (PC Register) ====================
// - 当前线程执行的字节码指令行号指示器
// - 唯一不会发生OOM的区域
// - 执行Java方法时记录字节码地址，执行Native方法时为Undefined

// ==================== 虚拟机栈 (JVM Stack) ====================
// - 每个方法调用创建一个栈帧(Stack Frame)
// - 栈帧包含：局部变量表、操作数栈、动态链接、方法返回地址
// - -Xss 设置栈大小（默认512K~1M）
// - 异常：StackOverflowError（栈深度超限）、OutOfMemoryError（无法申请栈空间）

public class StackDemo {
    // 触发 StackOverflowError
    static int depth = 0;

    public static void recursiveCall() {
        depth++;
        recursiveCall();  // 无限递归
    }

    public static void main(String[] args) {
        try {
            recursiveCall();
        } catch (StackOverflowError e) {
            System.out.println("栈溢出！递归深度: " + depth);
            // 默认栈大小约可递归 5000-20000 层
        }
    }
}

// ==================== 本地方法栈 (Native Method Stack) ====================
// - 为Native方法（JNI调用）服务
// - HotSpot中与虚拟机栈合并实现

// ==================== 堆 (Heap) ====================
// - 存放所有对象实例和数组
// - GC主要管理区域（"GC堆"）
// - -Xms 初始堆大小，-Xmx 最大堆大小（建议设为相同值，避免扩缩容开销）
// - 逻辑分代：新生代(Young) + 老年代(Old)

// 堆内存结构（以G1之前的经典分代为例）
//
// 新生代 (Young Generation)  —  -Xmn 或 -XX:NewRatio
// ┌────────────────────┬──────┬──────┐
// │   Eden (80%)       │ S0   │ S1   │  — 默认 Eden:S0:S1 = 8:1:1
// │   新对象分配于此     │(10%) │(10%) │  — -XX:SurvivorRatio=8
// └────────────────────┴──────┴──────┘
//
// 老年代 (Old Generation)
// ┌──────────────────────────────────┐
// │  长期存活对象、大对象               │
// │  -XX:MaxTenuringThreshold=15     │  — 晋升年龄（默认15）
// └──────────────────────────────────┘

// ==================== 方法区 / 元空间 (Metaspace) ====================
// - 存储类信息、常量、静态变量、JIT编译后的代码
// - JDK7及之前：PermGen（永久代），受-XX:MaxPermSize限制
// - JDK8+：Metaspace（元空间），使用本地内存，-XX:MaxMetaspaceSize
// - 运行时常量池是方法区的一部分

// TLAB (Thread Local Allocation Buffer)
// - 每个线程在Eden区预分配一小块私有缓冲区
// - 避免多线程分配对象时的锁竞争
// - -XX:+UseTLAB（默认开启）

// 方式一：引用计数法（Python使用，Java不用）
// 缺点：无法解决循环引用

// 方式二：可达性分析（Java采用）
// 从GC Roots出发，沿引用链搜索，不可达的对象判定为垃圾

// GC Roots包括：
// 1. 虚拟机栈中引用的对象（局部变量）
// 2. 方法区中静态属性引用的对象
// 3. 方法区中常量引用的对象
// 4. 本地方法栈中Native方法引用的对象
// 5. 同步锁持有的对象
// 6. JVM内部引用（基本类型包装类、系统类加载器等）

// 引用类型强度：强引用 > 软引用 > 弱引用 > 虚引用
Object strong = new Object();            // 强引用：GC绝不回收
SoftReference<Object> soft = new SoftReference<>(new Object());  // 软引用：内存不足时回收
WeakReference<Object> weak = new WeakReference<>(new Object());  // 弱引用：下次GC即回收
PhantomReference<Object> phantom = new PhantomReference<>(new Object(), queue); // 虚引用：配合ReferenceQueue

// G1 (Garbage-First) — JDK9+默认收集器
// 核心思想：将堆划分为大小相等的Region（1~32MB），按回收价值排序优先回收

// Region类型：
// Eden Region — 新对象分配
// Survivor Region — 新生代存活对象
// Old Region — 老年代对象
// Humongous Region — 大对象（> Region 50%）

// G1回收过程：
// 1. 初始标记（Initial Mark）— STW，标记GC Roots直接关联的对象
// 2. 并发标记（Concurrent Mark）— 与用户线程并发，遍历引用链
// 3. 最终标记（Final Mark）— STW，处理SATB（Snapshot-At-The-Beginning）遗留记录
// 4. 筛选回收（Cleanup/Evacuation）— STW，按Region回收价值排序，复制存活对象

// JVM参数
// -XX:+UseG1GC                         开启G1（JDK9+默认）
// -XX:MaxGCPauseMillis=200             目标最大停顿时间（默认200ms）
// -XX:G1HeapRegionSize=4m              Region大小（1~32MB，须为2的幂）
// -XX:G1NewSizePercent=5               新生代最小比例
// -XX:G1MaxNewSizePercent=60           新生代最大比例
// -XX:InitiatingHeapOccupancyPercent=45 触发Mixed GC的老年代占比阈值

// ZGC — 超低延迟收集器（STW < 1ms，不随堆大小增长）
// 核心技术：
// 1. 染色指针（Colored Pointers）— 在指针中存储GC元数据（标记、重映射）
// 2. 读屏障（Load Barrier）— 读取对象引用时检查指针状态
// 3. 并发整理 — 几乎所有阶段与用户线程并发

// 适用场景：
// - 超大堆（TB级别） + 要求极低延迟（金融、游戏）
// - JDK15+ 生产可用

// 启用ZGC
// -XX:+UseZGC
// -XX:+ZGenerational                   分代ZGC（JDK21+，默认开启）
// -Xmx16g                             设置最大堆

// 示例GC日志（G1）
// [0.123s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause)
//     Eden: 24M(24M)->0M(24M) Survivors: 0M->4M Heap: 24M(256M)->5M(256M)
// [0.123s][info][gc] GC(0) Pause Young (Normal) 24M->5M(256M) 3.456ms

// 关键指标：
// 1. GC频率（Young GC几秒一次算正常，Full GC应极少出现）
// 2. GC耗时（单次停顿几十ms内，累计占比<5%）
// 3. 内存回收效率（每次GC回收比例）
// 4. 堆使用趋势（是否持续增长 → 可能内存泄漏）

// 1. java.lang.OutOfMemoryError: Java heap space
//    原因：堆内存不足（对象过多或内存泄漏）
//    解决：增大-Xmx，排查泄漏

// 2. java.lang.OutOfMemoryError: Metaspace
//    原因：加载的类过多（如动态代理、CGLIB大量生成类）
//    解决：增大-XX:MaxMetaspaceSize

// 3. java.lang.OutOfMemoryError: GC overhead limit exceeded
//    原因：98%以上时间在GC，回收不到2%内存
//    解决：排查内存泄漏

// 4. java.lang.StackOverflowError
//    原因：栈深度超限（通常是无限递归）
//    解决：检查递归终止条件，增大-Xss

// 5. java.lang.OutOfMemoryError: Direct buffer memory
//    原因：NIO DirectByteBuffer溢出
//    解决：增大-XX:MaxDirectMemorySize

// 常见内存泄漏场景
public class MemoryLeakExamples {

    // 场景1：静态集合持续增长
    private static final List<byte[]> cache = new ArrayList<>();

    public void addToCache(byte[] data) {
        cache.add(data);  // 永远不清理 → 泄漏
    }

    // 场景2：未关闭的资源
    public void readFile(String path) throws Exception {
        InputStream is = new FileInputStream(path);
        // 忘记 is.close() → 资源泄漏
        // 正确做法：try-with-resources
    }

    // 场景3：监听器/回调未注销
    public void register() {
        EventBus.register(this);  // 注册后从不unregister
    }

    // 场景4：内部类持有外部类引用
    public class InnerTask implements Runnable {
        // 非静态内部类隐式持有外部类引用
        // 如果InnerTask被线程池持有 → 外部类无法被GC
        @Override
        public void run() { }
    }
}

// 排查流程：
// 1. 观察 → jstat -gcutil <pid> 查看Old区持续增长
// 2. 抓堆 → jmap -dump:format=b,file=heap.hprof <pid>
// 3. 分析 → 使用Eclipse MAT或VisualVM打开hprof
//    - Leak Suspects Report: 自动检测可疑泄漏点
//    - Dominator Tree: 查看对象占用排名
//    - GC Roots → 追踪引用链，定位是谁持有了不该持有的引用
// 4. 修复 → 清理引用、关闭资源、使用弱引用等

// HotSpot采用"解释执行 + JIT编译"混合模式
// 热点代码（方法调用计数器 / 回边计数器超过阈值）触发JIT编译为本地机器码

// ==================== 逃逸分析 ====================
// 分析对象是否逃逸到方法/线程外部
// 不逃逸的对象可进行以下优化：

// 1. 栈上分配：对象不逃逸 → 在栈帧中分配，方法结束自动回收，不进入堆
public void process() {
    Point p = new Point(1, 2);  // p不逃逸 → 可能在栈上分配
    int sum = p.x + p.y;
    System.out.println(sum);
}

// 2. 标量替换：对象拆解为基本类型
// Point p = new Point(1, 2); → 替换为 int x = 1; int y = 2;

// 3. 锁消除：对象不逃逸 → 去除无意义的同步
public String concat(String a, String b) {
    StringBuffer sb = new StringBuffer();  // sb不逃逸
    sb.append(a);
    sb.append(b);
    return sb.toString();
    // JIT可能消除StringBuffer内部的synchronized
}

// ==================== 方法内联 ====================
// 将方法调用替换为方法体本身，减少调用开销
// -XX:MaxInlineSize=35       — 方法字节码 ≤ 35字节自动内联
// -XX:FreqInlineSize=325     — 热点方法字节码 ≤ 325字节自动内联

// ==================== 循环优化 ====================
// 循环展开、循环判断外提等

// JIT相关参数
// -XX:-TieredCompilation         关闭分层编译
// -XX:CompileThreshold=10000     方法调用计数阈值
// -XX:+PrintCompilation          打印JIT编译信息