WeakReference 在缓存中的应用

WeakReference 是 Java 中的一种引用类型，它允许你持有对对象的弱引用。这意味着，如果一个对象只被 WeakReference 引用，那么它就有资格被垃圾回收器回收。这种特性使得 WeakReference 非常适合用于实现缓存。

在缓存中，我们通常希望缓存的对象能够在内存充足的时候保留在缓存中，而在内存不足的时候能够被回收。使用 WeakReference 可以实现这一目标，因为当对象只被 WeakReference 引用时，垃圾回收器可以在任何时候回收它。

以下是 WeakReference 在缓存中的一些应用：

1. 软引用缓存（SoftReference Cache）

虽然这不是直接使用 WeakReference，但软引用（SoftReference）与弱引用类似，只是软引用在内存不足时才会被回收。软引用缓存适用于那些希望在内存紧张时才被回收的对象。

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

public class SoftReferenceCache<K, V> {
    private final Map<K, SoftReference<V>> cache = new HashMap<>();

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

    public V get(K key) {
        SoftReference<V> reference = cache.get(key);
        if (reference != null) {
            return reference.get();
        }
        return null;
    }

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

2. 弱引用缓存（WeakReference Cache）

直接使用 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>> cache = new HashMap<>();

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

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

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

3. 结合 ReferenceQueue 使用

为了更好地管理被回收的对象，可以结合 ReferenceQueue 使用。当对象被回收时，WeakReference 会被加入到 ReferenceQueue 中，从而可以及时清理缓存。

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

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

    public WeakReferenceCache() {
        // 启动一个线程来清理被回收的对象
        Thread cleaner = new Thread(() -> {
            while (true) {
                try {
                    Reference<? extends V> reference = referenceQueue.remove();
                    if (reference instanceof WeakReference) {
                        WeakReference<V> weakReference = (WeakReference<V>) reference;
                        cache.values().remove(weakReference);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        cleaner.setDaemon(true);
        cleaner.start();
    }

    public void put(K key, V value) {
        cleanUp(); // 清理已经被回收的对象
        cache.put(key, new WeakReference<>(value, referenceQueue));
    }

    public V get(K key) {
        cleanUp(); // 清理已经被回收的对象
        WeakReference<V> reference = cache.get(key);
        if (reference != null) {
            return reference.get();
        }
        return null;
    }

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

    private void cleanUp() {
        WeakReference<?> reference;
        while ((reference = (WeakReference<?>) referenceQueue.poll()) != null) {
            cache.values().remove(reference);
        }
    }
}

总结

WeakReference 在缓存中的应用主要是为了实现一种能够在内存不足时自动回收对象的缓存机制。通过结合 ReferenceQueue，可以更有效地管理被回收的对象，从而保持缓存的清洁和高效。