四种引用类型：强引用、软引用、弱引用、虚引用

public class StrongRefDemo {
    public static void main(String[] args) {
        Object obj = new Object();   // obj 是强引用

        // 即使内存不够，GC 也不会回收 obj 指向的对象
        // 宁可抛出 OOM，也不会回收强引用对象

        obj = null;  // ★ 显式设为 null 才能断开引用
        // 此时对象变为不可达，可以被 GC 回收
    }
}

// 常见的强引用泄漏场景：
// ① 集合中对象忘记 remove
List<Object> cache = new ArrayList<>();
cache.add(bigObject);    // cache 强引用 bigObject → 永不回收

// ② 静态集合
static Map<String, Object> globalMap = new HashMap<>();
globalMap.put("key", bigObject);  // 静态变量生命周期=JVM 生命周期

// ③ ThreadLocal 中的 Value（见 ThreadLocal 那篇）

public class ImageCache {
    // key=图片路径, value=图片对象的软引用
    private Map<String, SoftReference<Image>> cache = new HashMap<>();

    public Image getImage(String path) {
        SoftReference<Image> ref = cache.get(path);
        if (ref != null) {
            Image img = ref.get();  // ★ 可能返回 null（已被 GC 回收）
            if (img != null) {
                return img;  // 缓存命中
            }
        }
        // 缓存未命中或已被回收，重新加载
        Image img = loadImageFromDisk(path);
        cache.put(path, new SoftReference<>(img));
        return img;
    }
}

/*
 * GC 行为：
 * - 内存充足 → SoftReference 指向的对象不会被回收
 * - 内存紧张 → GC 会回收 SoftReference 指向的对象（在抛出 OOM 之前）
 *
 * JDK 回收策略（近似）：
 * 软引用对象的存活时间 < (JVM 空闲内存 MB)
 * 即空闲内存越多，软引用存活越久
 */

Object obj = new Object();
WeakReference<Object> weakRef = new WeakReference<>(obj);

System.out.println(weakRef.get());  // java.lang.Object@xxx

obj = null;   // 断开强引用
System.gc();   // 建议 GC

System.out.println(weakRef.get());  // null ★ 对象已被回收！

// 对比软引用：
Object obj2 = new Object();
SoftReference<Object> softRef = new SoftReference<>(obj2);
obj2 = null;
System.gc();
System.out.println(softRef.get());  // 仍然有值（内存充足不回收）

WeakHashMap<Object, String> map = new WeakHashMap<>();

Object key1 = new Object();
Object key2 = new Object();

map.put(key1, "value1");
map.put(key2, "value2");

System.out.println(map.size());  // 2

key1 = null;  // 断开 key1 的强引用
System.gc();

// ★ key1 对应的 Entry 被自动移除！
System.out.println(map.size());  // 1

/*
 * WeakHashMap 原理：
 * - Entry 继承 WeakReference，key 是弱引用
 * - 当 key 不再被外部强引用时，GC 回收 key
 * - WeakHashMap 在下次操作时，通过 ReferenceQueue 感知到 key 被回收
 * - 自动移除对应的 Entry（包括 value）
 */

ReferenceQueue<Object> queue = new ReferenceQueue<>();

Object obj = new Object();
PhantomReference<Object> phantom = new PhantomReference<>(obj, queue);

// ★ get() 永远返回 null！虚引用无法获取对象
System.out.println(phantom.get());  // null

obj = null;  // 断开强引用
System.gc();

// GC 回收对象后，PhantomReference 被放入队列
Reference<?> ref = queue.poll();
System.out.println(ref == phantom);  // true ★ 确认对象已被回收

/*
 * 虚引用的设计意图：
 * ① 无法通过虚引用获取对象 → 不会"意外复活"对象
 * ② 对象被回收时收到通知 → 可以做清理工作（释放堆外内存等）
 * ③ 比 finalize() 更安全 → 不会导致对象复活或性能问题
 */

import java.lang.ref.Cleaner;

public class ResourceHolder implements AutoCloseable {
    private static final Cleaner cleaner = Cleaner.create();

    // ★ 清理逻辑必须放在独立的静态内部类中
    // 不能持有外部类的引用（否则阻止回收）
    private static class CleanAction implements Runnable {
        private final long nativeHandle;

        CleanAction(long handle) { this.nativeHandle = handle; }

        @Override
        public void run() {
            // ★ 对象被 GC 后，Cleaner 会调用此方法
            freeNativeResource(nativeHandle);
        }
    }

    private final Cleaner.Cleanable cleanable;

    public ResourceHolder(long handle) {
        // 注册清理动作：当 this 被 GC 时，执行 CleanAction
        this.cleanable = cleaner.register(this, new CleanAction(handle));
    }

    @Override
    public void close() {
        cleanable.clean();  // 主动清理（不必等 GC）
    }
}

/*
 * Cleaner 底层使用 PhantomReference + ReferenceQueue
 * JDK 内部 DirectByteBuffer 的 Cleaner 就是这样实现的：
 * 当 DirectByteBuffer 被 GC 时，Cleaner 负责释放堆外内存
 */

ReferenceQueue<Object> queue = new ReferenceQueue<>();
Map<WeakReference<Object>, String> metadata = new HashMap<>();

// 创建对象并注册弱引用
for (int i = 0; i < 5; i++) {
    Object obj = new Object();
    WeakReference<Object> ref = new WeakReference<>(obj, queue);
    metadata.put(ref, "metadata-" + i);
    // obj 局部变量，循环结束后无强引用
}

System.gc();

// ★ 从队列中取出被回收的引用，做清理
Reference<? extends Object> ref;
while ((ref = queue.poll()) != null) {
    String meta = metadata.remove(ref);
    System.out.println("清理元数据: " + meta);
}

/*
 * 各引用类型的入队时机：
 * 软引用：对象被 GC 回收后入队
 * 弱引用：对象被 GC 回收后入队
 * 虚引用：★ 对象被 GC 回收后，从 Finalizer 队列移除后才入队
 *         （即对象真的"死透了"才入队，不像 finalize 可能复活对象）
 */