Java 的 WeakHashMap 和缓存：为什么它引用键而不是值？

Question

Java 的WeakHashMap 经常被认为对缓存很有用。虽然它的弱引用是根据映射的键而不是它的值来定义的，但这似乎很奇怪。我的意思是，这是我想要缓存的值，一旦除了缓存之外没有其他人强烈引用它们，我想收集垃圾，不是吗？

在哪些方面有助于保持对键的弱引用？如果您执行ExpensiveObject o = weakHashMap.get("some_key")，那么我希望缓存保持为'o'，直到调用者不再持有强引用，并且我根本不关心字符串对象“some_key”。

我错过了什么吗？

Answer 1

WeakHashMap 没有作为缓存有用，至少大多数人认为它是这样。正如你所说，它使用弱 keys，而不是弱 values，所以它不是为大多数人想要使用它而设计的（事实上，我已经 见过人们错误地使用它）。

WeakHashMap 对于保存您无法控制其生命周期的对象的元数据非常有用。例如，如果您有一堆对象通过您的类，并且您希望跟踪有关它们的额外数据，而不需要在它们超出范围时得到通知，也不需要您对它们的引用来使它们保持活动状态。

一个简单的例子（我以前用过的）可能是这样的：

WeakHashMap<Thread, SomeMetaData>

您可以在其中跟踪系统中的各个线程正在执行的操作；当线程终止时，该条目将从您的地图中静默删除，如果您是对它的最后引用，您将不会阻止该线程被垃圾收集。然后，您可以遍历该映射中的条目，以找出您拥有的有关系统中活动线程的元数据。

更多信息请参见WeakHashMap in not a cache!。

对于您所追求的缓存类型，请使用专用缓存系统（例如EHCache）或查看Guava 的MapMaker class；像

new MapMaker().weakValues().makeMap();

会做你所追求的，或者如果你想变得花哨，你可以添加定时过期：

new MapMaker().weakValues().expiration(5, TimeUnit.MINUTES).makeMap();

Answer 2

WeakHashMap 的主要用途是当您有映射时，您想在它们的键消失时消失。缓存是相反的——当它们的值消失时，你有想要消失的映射。

对于缓存，您需要的是Map<K,SoftReference<V>>。当内存紧张时，SoftReference 将被垃圾收集。 （将其与WeakReference 进行对比，一旦不再有对其所指对象的硬引用，它就可能被清除。）您希望您的引用在缓存中是软的（至少在键值映射不存在的地方） t 过时），从那时起，如果您稍后查找它们，您的值仍有可能在缓存中。相反，如果引用很弱，您的值将立即被 gc'd，从而破坏了缓存的目的。

为方便起见，您可能希望在您的Map 实现中隐藏SoftReference 值，以便您的缓存看起来是<K,V> 类型而不是<K,SoftReference<V>>。如果你想这样做，this question 有网络上可用的实现建议。

还请注意，当您在 Map 中使用 SoftReference 值时，您必须手动删除已清除其 SoftReferences 的键值对---否则您的Map 只会永远变大，而且会泄漏内存。

Answer 3

要考虑的另一件事是，如果您采用Map<K, WeakReference<V>> 方法，该值可能会消失，但映射不会。根据使用情况，您最终可能会得到一个包含许多弱引用已被 GC'd 的条目的 Map。

Answer 4

您需要两个映射：一个在缓存键和weak referenced 值之间进行映射，另一个在弱引用值和键之间进行反向映射。你需要一个reference queue 和一个清理线程。

当被引用对象无法再访问时，弱引用能够将引用移动到队列中。该队列必须由清理线程清空。 为了进行清理，需要获取密钥以供参考。这就是需要第二张地图的原因。

以下示例显示了如何使用弱引用的哈希映射创建缓存。当你运行程序时，你会得到以下输出：

$ javac -Xlint:unchecked Cache.java && java Cache {偶数：[2, 4, 6]，奇数：[1, 3, 5]} {偶数：[2, 4, 6]}

第一行显示删除奇数列表引用之前缓存的内容，第二行显示删除奇数列表后的内容。

这是代码：

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

class Cache<K,V>
{
    ReferenceQueue<V> queue = null;
    Map<K,WeakReference<V>> values = null;
    Map<WeakReference<V>,K> keys = null;
    Thread cleanup = null;

    Cache ()
    {
        queue  = new ReferenceQueue<V>();
        keys   = Collections.synchronizedMap (new HashMap<WeakReference<V>,K>());
        values = Collections.synchronizedMap (new HashMap<K,WeakReference<V>>());
        cleanup = new Thread() {
                public void run() {
                    try {
                        for (;;) {
                            @SuppressWarnings("unchecked")
                            WeakReference<V> ref = (WeakReference<V>)queue.remove();
                            K key = keys.get(ref);
                            keys.remove(ref);
                            values.remove(key);
                        }
                    }
                    catch (InterruptedException e) {}
                }
            };
        cleanup.setDaemon (true);
        cleanup.start();
    }

    void stop () {
        cleanup.interrupt();
    }

    V get (K key) {
        return values.get(key).get();
    }

    void put (K key, V value) {
        WeakReference<V> ref = new WeakReference<V>(value, queue);
        keys.put (ref, key);
        values.put (key, ref);
    }

    public String toString() {
        StringBuilder str = new StringBuilder();
        str.append ("{");
        boolean first = true;
        for (Map.Entry<K,WeakReference<V>> entry : values.entrySet()) {
            if (first)
                first = false;
            else
                str.append (", ");
            str.append (entry.getKey());
            str.append (": ");
            str.append (entry.getValue().get());
        }
        str.append ("}");
        return str.toString();
    }

    static void gc (int loop, int delay) throws Exception
    {
        for (int n = loop; n > 0; n--) {
            Thread.sleep(delay);
            System.gc(); // <- obstinate donkey
        }
    }

    public static void main (String[] args) throws Exception
    {
        // Create the cache
        Cache<String,List> c = new Cache<String,List>();

        // Create some values
        List odd = Arrays.asList(new Object[]{1,3,5});
        List even = Arrays.asList(new Object[]{2,4,6});

        // Save them in the cache
        c.put ("odd", odd);
        c.put ("even", even);

        // Display the cache contents
        System.out.println (c);

        // Erase one value;
        odd = null;

        // Force garbage collection
        gc (10, 10);

        // Display the cache again
        System.out.println (c);

        // Stop cleanup thread
        c.stop();
    }
}