WeakReference在Java集合中的应用

WeakReference 是 Java 中的一个类，它允许你创建一个对对象的弱引用。当垃圾回收器运行时，如果一个对象只被弱引用所引用，那么它会被回收。这在 Java 集合中有一些应用场景，尤其是在缓存实现中。

以下是 WeakReference 在 Java 集合中的一些应用：

1. 缓存实现

使用 WeakReference 可以实现一个简单的缓存机制。当内存不足时，垃圾回收器可以回收那些只被弱引用所引用的对象，从而避免内存溢出。

import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

public class WeakReferenceCache<K, V> {
    private final Map<K, WeakReference<V>> map = new HashMap<>();

    public void put(K key, V value) {
        map.put(key, new WeakReference<>(value));
    }

    public V get(K key) {
        WeakReference<V> weakReference = map.get(key);
        if (weakReference != null) {
            return weakReference.get();
        }
        return null;
    }

    public void remove(K key) {
        map.remove(key);
    }
}

2. 避免内存泄漏

在使用集合时，如果不小心将对象的引用保留在集合中，可能会导致内存泄漏。使用 WeakReference 可以避免这种情况，因为当对象不再被其他强引用持有时，垃圾回收器可以回收它。

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

public class WeakReferenceExample {
    public static void main(String[] args) {
        List<WeakReference<Object>> list = new ArrayList<>();
        Object obj = new Object();
        list.add(new WeakReference<>(obj));

        // 现在 obj 只被 list 中的一个弱引用所引用
        obj = null; // 移除强引用

        // 垃圾回收器可以回收 obj，因为没有其他强引用指向它
        System.gc();

        // 检查 list 中的对象是否已经被回收
        for (WeakReference<Object> weakReference : list) {
            if (weakReference.get() == null) {
                System.out.println("Object has been garbage collected");
            } else {
                System.out.println("Object is still alive");
            }
        }
    }
}

3. 软引用与弱引用的结合

在某些情况下，你可能需要结合使用软引用（SoftReference）和弱引用（WeakReference）来实现更复杂的缓存策略。例如，你可以使用软引用作为一级缓存，使用弱引用作为二级缓存。

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

public class CombinedReferenceCache<K, V> {
    private final Map<K, SoftReference<V>> softMap = new HashMap<>();
    private final Map<K, WeakReference<V>> weakMap = new HashMap<>();

    public void put(K key, V value) {
        softMap.put(key, new SoftReference<>(value));
        weakMap.put(key, new WeakReference<>(value));
    }

    public V get(K key) {
        SoftReference<V> softReference = softMap.get(key);
        if (softReference != null) {
            V value = softReference.get();
            if (value != null) {
                return value;
            }
        }

        WeakReference<V> weakReference = weakMap.get(key);
        if (weakReference != null) {
            return weakReference.get();
        }

        return null;
    }

    public void remove(K key) {
        softMap.remove(key);
        weakMap.remove(key);
    }
}

总之，WeakReference 在 Java 集合中的应用主要体现在缓存实现、避免内存泄漏以及结合软引用实现更复杂的缓存策略等方面。