一张图搞懂 Java 四种引用——强软弱虚的原理与实战场景

public class ReferenceDemo {
    public static void main(String[] args) {
        Object obj = new Object();                          // ①
        WeakReference<Object> weak = new WeakReference<>(obj); // ②
        obj = null;                                         // ③
        System.gc();                                        // ④
        System.out.println(weak.get());                     // ⑤ 输出 null
    }
}

flowchart LR
    A["new Object()
堆上对象"]:::object
    B["obj（强引用）"]:::strong
    C["WeakReference（弱引用）"]:::weak

    A -->|"② 弱引用指向"| C
    A -->|"① 强引用指向"| B
    B -.->|"③ obj = null
强引用断开"| X1[" "]
    A -.->|"④ GC 触发"| X2["回收对象"]:::gc

    classDef object fill:#f9f,stroke:#333,color:#000
    classDef strong fill:#ff6b6b,stroke:#c0392b,color:#000
    classDef weak fill:#ffd93d,stroke:#f39c12,color:#000
    classDef gc fill:#6bcb77,stroke:#27ae60,color:#000

User user = new User();     // 强引用
List<String> list = new ArrayList<>();  // 强引用

public static final List<Data> CACHE = new ArrayList<>();
while (true) {
    CACHE.add(new Data());  // 强引用链：CACHE → ArrayList → Data
    // 内存只增不减，直到 OOM
}

// 软引用的典型用法
SoftReference<Bitmap> softRef = new SoftReference<>(bitmap);

// 获取对象
Bitmap cachedBitmap = softRef.get();
if (cachedBitmap == null) {
    // 被 GC 回收了，重新加载
    cachedBitmap = loadBitmap();
}

flowchart TD
    Start["软引用指向的对象"] --> Check{"GC 触发"}
    Check -->|"当前堆内存充足"| Keep["保留对象
softRef.get() 返回正常"]
    Check -->|"当前堆内存不足"| Recycle["回收对象
softRef.get() 返回 null"]
    Keep --> End["继续使用缓存"]
    Recycle --> Oom["腾出空间，避免 OOM"]

    style Keep fill:#6bcb77,stroke:#27ae60,color:#000
    style Recycle fill:#ff6b6b,stroke:#c0392b,color:#000

public class ImageCache {
    private final Map<String, SoftReference<BufferedImage>> cache = new HashMap<>();

    public BufferedImage get(String key) {
        SoftReference<BufferedImage> ref = cache.get(key);
        if (ref != null) {
            BufferedImage img = ref.get();
            if (img != null) return img;
        }
        // 缓存失效，从磁盘加载
        BufferedImage img = loadFromDisk(key);
        cache.put(key, new SoftReference<>(img));
        return img;
    }
}

WeakReference<Object> weak = new WeakReference<>(new Object());
System.gc();
System.out.println(weak.get());  // null，一次 GC 就被回收了

Map<Key, Value> map = new WeakHashMap<>();
Key key = new Key("session-1");
map.put(key, "data");
System.out.println(map.size());  // 1

key = null;  // 唯一的强引用被切断
System.gc();
System.out.println(map.size());  // 0，自动清理了

// ThreadLocalMap.Entry 的简化源码
static class Entry extends WeakReference<ThreadLocal> {
    Object value;
    Entry(ThreadLocal k, Object v) {
        super(k);  // key 是弱引用！
        value = v; // value 是强引用！
    }
}

ThreadLocal<Session> tl = new ThreadLocal<>();
tl.set(new Session("admin"));

// 如果忘记 remove()
// tl = null;  // ThreadLocal 对象变成弱引用可达，下一轮 GC 被回收
// 但 Entry 中的 value（Session 对象）仍然被强引用着！
// 只要线程存活，value 就永远无法被回收 → 内存泄漏

flowchart TB
    subgraph "Thread"
        T["Thread 对象"] --> Map["ThreadLocalMap"]
        Map --> E1["Entry 1
key: WeakReference
value: Session 对象"]
        Map --> E2["Entry 2
..."]
    end
    subgraph "外部"
        TL["ThreadLocal tl"]:::strong
    end

    TL -- "set()" --> E1
    TL -.->|"tl = null 后
弱引用断裂"| Break["Key 被 GC 回收"]
    E1 -->|"value 仍是强引用
Session 对象无法回收！"| Leak["☠ 内存泄漏"]:::leak

    classDef strong fill:#ff6b6b,stroke:#c0392b,color:#000
    classDef leak fill:#e74c3c,stroke:#c0392b,color:#fff

// 务必在 finally 块中清理
ThreadLocal<Session> tl = new ThreadLocal<>();
try {
    tl.set(new Session("admin"));
    // ... 业务逻辑
} finally {
    tl.remove();  // 清除 Entry，避免内存泄漏
}

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

System.out.println(phantom.get());  // 永远返回 null！

// DirectByteBuffer 内部核心逻辑（简化版）
public class DirectByteBuffer {
    private static class Deallocator implements Runnable {
        private final long address;  // 堆外内存地址

        @Override
        public void run() {
            // unsafe.freeMemory(address);  // 释放堆外内存
        }
    }

    private final Cleaner cleaner;  // 虚引用的具体实现

    DirectByteBuffer(int cap) {
        // 分配堆外内存
        long address = unsafe.allocateMemory(cap);
        cleaner = Cleaner.create(this, new Deallocator(address));
        // 当 DirectByteBuffer 对象被回收时，
        // Cleaner 会触发 Deallocator 释放堆外内存
    }
}

flowchart LR
    subgraph "堆内存"
        DBB["DirectByteBuffer 对象
堆上几十字节"]:::heap
    end
    subgraph "堆外内存"
        Off["堆外内存区域
可能几十 MB"]:::offheap
    end

    DBB -->|"维护引用"| Off
    DBB -->|"绑定了虚引用"| Cleaner["Cleaner
PhantomReference 实现"]
    DBB -.->|"DBB 被 GC 回收后"| Cleaner
    Cleaner -->|"自动触发"| Deallocator["Deallocator.run()
释放堆外内存"]

    classDef heap fill:#f9f,stroke:#333,color:#000
    classDef offheap fill:#ffd93d,stroke:#f39c12,color:#000

public class AutoCleanCache<K, V> {
    private final ConcurrentHashMap<K, SoftReference<V>> cache = new ConcurrentHashMap<>();
    private final ReferenceQueue<V> queue = new ReferenceQueue<>();

    public void put(K key, V value) {
        expungeStaleEntries();  // 清理已被回收的条目
        cache.put(key, new SoftReference<>(value, queue));
    }

    public V get(K key) {
        SoftReference<V> ref = cache.get(key);
        return ref != null ? ref.get() : null;
    }

    private void expungeStaleEntries() {
        Reference extends V> ref;
        while ((ref = queue.poll()) != null) {
            // 从 cache 中移除对应的 key
            cache.entrySet().removeIf(entry -> entry.getValue() == ref);
        }
    }
}