JVM 垃圾回收算法详解

/**
 * 垃圾：无用的对象占据着内存空间
 * 判断对象是否存活的算法：
 * 1. 引用计数算法
 * 2. 可达性分析算法
 */
public class GCHellowWorld {
    public static void main(String[] args) {
        // 循环引用示例
        Object a = new Object();
        Object b = new Object();
        a = null;  // a 变成垃圾
        b = null;  // b 变成垃圾
        // 此时两个对象互相引用，但都没有外部引用，仍然是垃圾
    }
}

/**
 * 原理：对象每被引用一次，计数器+1；引用失效时-1
 * 缺点：无法处理循环引用
 */
public class ReferenceCounting {
    public Object instance;
    public static void main(String[] args) {
        // 循环引用问题
        ReferenceCounting objA = new ReferenceCounting();
        ReferenceCounting objB = new ReferenceCounting();
        
        objA.instance = objB;
        objB.instance = objA;
        
        objA = null;
        objB = null;
        
        // 此时两个对象引用计数都不为0，但实际上已经不可达
        // 纯引用计数算法无法识别这种垃圾
    }
}

/**
 * 原理：从 GC Root 出发，可达的对象存活，不可达的对象是垃圾
 *
 * GC Root 包含：
 * - 虚拟机栈中引用的对象
 * - 方法区中静态属性引用的对象
 * - 方法区中常量引用的对象
 * - 本地方法栈中 Native 方法引用的对象
 */
public class GCReachability {
    // 静态属性 - GC Root
    private static Object staticObject;
    
    // 局部变量 - GC Root
    private Object instance;
    
    public static void main(String[] args) {
        // 可达
        staticObject = new Object();
        
        // 不可达（局部变量随着方法结束出栈）
        Object local = new Object();
        local = null;
    }
}

/**
 * 过程：
 * 1. 标记阶段：标记所有需要回收的对象
 * 2. 清除阶段：统一清除被标记的对象
 *
 * 缺点：
 * - 效率低（标记和清除都慢）
 * - 空间碎片化（产生不连续的内存）
 */
public class MarkSweepDemo {
    /*
     * 标记前：
     * [对象A][空闲][对象B][对象C][空闲]
     *
     * 标记后（假设B是垃圾）：
     * [对象A][空闲][XXXXX][对象C][空闲]
     *
     * 清除后：
     * [对象A][空闲        ][对象C][空闲]
     *       ↑ 产生内存碎片
     */
}

/**
 * 原理：将内存分为两半，每次只使用一半
 * 存活对象复制到另一半，然后清除原半区
 *
 * 优点：无碎片、简单高效
 * 缺点：可用内存减半
 *
 * 商用实现：Eden + Survivor（8:1:1）
 */
public class CopyingDemo {
    /*
     * 初始状态：
     * ┌─────────────────────────┬─────────────────────────┐
     │        From 区           │        To 区            │
     │  [A][B][C][D][存活对象]   │        [空]            │
     │  (需要回收)              │                         │
     * └─────────────────────────┴─────────────────────────┘
     *
     * 复制后：
     * ┌─────────────────────────┬─────────────────────────┐
     │        From 区           │        To 区            │
     │        [空]              │  [A'][B'][存活对象']    │
     * └─────────────────────────┴─────────────────────────┘
     */
}

/**
 * 原理：标记后移动存活对象到一端，然后清理边界外的内存
 *
 * 优点：无碎片
 * 缺点：移动对象开销大（需要更新引用）
 *
 * 适用：老年代（对象存活率高）
 */
public class MarkCompactDemo {
    /*
     * 标记后：
     * [A][B][C][空闲][D][E][空闲]
     *      ↑
     *   存活对象
     *
     * 整理后：
     * [A][B][C][D][E][空闲       ]
     *                ↑
     *             整理边界
     */
}

/**
 * 核心思想：不同对象生命周期不同，采用不同的收集策略
 *
 * ┌─────────────────────────────────────────┐
 │                  堆内存                    │
 │  ┌─────────────┬───────────────────────┐│
 │  │   新生代    │       老年代           ││
 │  │ (Minor GC) │    (Major/Full GC)     ││
 │  │  复制算法   │   标记-整理算法        ││
 │  └─────────────┴───────────────────────┘│
 │ 新生代 90% 对象朝生夕死                   │
 │ 老年代 多次 GC 后仍存活                   │
 └─────────────────────────────────────────┘
 */
public class GenerationalDemo {
    public static void main(String[] args) {
        // 新生代对象：短生命周期
        for (int i = 0; i < 100; i++) {
            String s = "temp" + i;  // 使用完立即成为垃圾
        }
        
        // 老年代对象：长生命周期
        List<String> cache = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            cache.add("persistent" + i);  // 长期存活
        }
    }
}

/**
 * Serial 收集器（单线程）
 * - 复制算法
 * - Stop The World
 * - 简单高效（无线程开销）
 * - 客户端模式
 */
public class SerialGC {
    // -XX:+UseSerialGC
}

/**
 * ParNew 收集器（多线程）
 * - 复制算法
 * - Stop The World
 * - 可与 CMS 配合
 * - 服务端模式
 */
public class ParNewGC {
    // -XX:+UseParNewGC
}

/**
 * Parallel Scavenge 收集器
 * - 复制算法
 * - 吞吐量优先
 * - 自适应调节
 */
public class ParallelScavengeGC {
    // -XX:+UseParallelGC
    // -XX:MaxGCPauseMillis=100  // 最大停顿时间
    // -XX:GCTimeRatio=19        // 吞吐量
}

/**
 * Serial Old 收集器
 * - 标记-整理算法
 * - 单线程
 */
public class SerialOldGC {
    // -XX:+UseSerialOldGC
}

/**
 * Parallel Old 收集器
 * - 标记-整理算法
 * - 多线程
 */
public class ParallelOldGC {
    // -XX:+UseParallelOldGC
}

/**
 * CMS 收集器（Concurrent Mark Sweep）
 * - 标记-清除算法
 * - 并发收集、低停顿
 * - 浮动垃圾问题
 * - 内存碎片问题
 */
public class CMSGC {
    // -XX:+UseConcMarkSweepGC
    /*
     * 收集过程：
     * 1. 初始标记（STW）     - 标记 GC Root
     * 2. 并发标记            - 追踪存活对象
     * 3. 重新标记（STW）     - 修正变化
     * 4. 并发清除            - 清除垃圾
     */
}

/**
 * G1 收集器（Garbage First）
 * - 复制+标记-整理
 * - 区域（Region）概念
 * - 可预测停顿
 * - JDK 9+ 默认
 */
public class G1GC {
    // -XX:+UseG1GC
    // -XX:MaxGCPauseMillis=200
}