#垃圾回收判定算法

public class ReferenceCountingDemo {
    public static void main(String[] args) {
        Object obj1 = new Object();  // 计数器 = 1
        Object obj2 = obj1;          // 计数器 = 2
        
        obj1 = null;                 // 计数器 = 1
        
        obj2 = null;                 // 计数器 = 0，对象可回收
    }
}

public class CircularReference {
    public static void main(String[] args) {
        // 创建两个对象，互相引用
        ObjectA a = new ObjectA();
        ObjectB b = new ObjectB();
        
        a.ref = b;  // a 持有 b 的引用
        b.ref = a;  // b 持有 a 的引用
        
        // 此时 a 和 b 的引用计数都是 1
        
        // 但如果外部不再持有 a 和 b 的引用
        a = null;
        b = null;
        
        // a 和 b 已经不可达，但引用计数都是 1
        // 引用计数法无法回收这两个对象！
    }
}

class ObjectA {
    ObjectB ref;
}

class ObjectB {
    ObjectA ref;
}

public class GCRootsDemo {
    // 1. 静态属性（静态变量）
    static Object staticObj = new Object();
    
    // 2. 常量
    static final Object CONSTANT_OBJ = new Object();
    
    public void method() {
        // 3. 栈帧中的局部变量
        Object localObj = new Object();
        
        // 4. 锁对象
        synchronized (localObj) {
            // 正在被锁住的对象也是 GC Root
        }
    }
}

public class TracingDemo {
    public static void main(String[] args) {
        // 1. 方法中的局部变量是 GC Root
        Object root = new Object();
        
        // 2. 创建引用链
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        
        a.ref = b;
        b.ref = c;
        c.ref = a;
        
        // 3. 此时 a -> b -> c 形成循环
        // 但它们都被 root 引用，所以都是存活的
        
        // 4. 断开引用链
        root = null;
        a = null;
        b = null;
        c = null;
        
        // 5. 现在 a、b、c 都不被 GC Roots 引用
        // 即使它们内部相互引用，也会被回收
    }
}

public class WhyReachability {
    public static void main(String[] args) {
        // 可达性分析可以正确处理循环引用
        Node a = new Node();
        Node b = new Node();
        a.next = b;
        b.next = a;
        
        // 即使 a 和 b 相互引用
        // 如果它们不再被 GC Roots 引用，就会被回收
    }
}

public class StrongReference {
    public static void main(String[] args) {
        // 强引用：永远不会 GC
        Object obj = new Object();  // 强引用
        
        obj = null;  // 断开引用，对象才可能被回收
        
        // 即使内存不足，JVM 抛出 OOM，也不会回收强引用对象
    }
}

import java.lang.ref.SoftReference;

public class SoftReferenceDemo {
    public static void main(String[] args) {
        // 软引用：内存不足时才会回收
        SoftReference<byte[]> softRef = new SoftReference<>(new byte[1024 * 1024 * 10]);
        
        // 软引用常用于缓存
        // 当内存充足时，对象保留；内存不足时，对象被回收
    }
}

import java.lang.ref.WeakReference;

public class WeakReferenceDemo {
    public static void main(String[] args) {
        // 弱引用：下一次 GC 时一定会回收
        WeakReference<Object> weakRef = new WeakReference<>(new Object());
        
        // 下一次 GC 时，无论内存是否充足，对象都会被回收
    }
}

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceDemo {
    public static void main(String[] args) {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        
        // 虚引用：无法通过 get() 获取对象
        // 唯一作用是追踪对象被回收的时机
        PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), queue);
        
        // 当对象被回收时，phantomRef 会被加入 queue
    }
}

public class FinalizeEscape {
    static Object object;
    
    public static void main(String[] args) throws InterruptedException {
        object = new Object();
        
        // 第一次 GC
        object = null;
        System.gc();
        Thread.sleep(500);
        
        if (object != null) {
            System.out.println("对象复活了！");
        }
        
        // 第二次 GC
        object = null;
        System.gc();
        Thread.sleep(500);
        
        if (object == null) {
            System.out.println("对象最终死亡");
        }
    }
    
    // 重写 finalize()，尝试自救
    @Override
    protected void finalize() throws Throwable {
        object = this;  // 自救：将 this 赋值给静态变量
        System.out.println("finalize() 被调用，尝试自救");
    }
}

public class BadFinalizePractice {
    public static void main(String[] args) {
        // 错误：finalize() 执行时机不确定
        // 错误：只会被调用一次
        // 正确做法：使用 try-with-resources 或主动清理
    }
}