Java中有SoftHashMap吗？

Question

我知道 java.util 中有一个 WeakHashMap，但由于它对所有内容都使用 WeakReference，因此仅由此 引用Map，引用的对象将在下一个GC周期中丢失。 因此，如果您想缓存随机数据，那么它几乎没有用处，因为在其余时间很可能会再次请求这些数据而不会进行硬链接。 最好的解决方案是一张地图，它使用 SoftReference 来代替，但我在 Java RT 包中没有找到。

Answer 1

编辑（2012 年 8 月）：

事实证明，目前最好的解决方案可能是 Guava 13.0 的 Cache 类，解释于 Guava 的 Wiki - 这就是我要使用的。
它甚至支持构建 SoftHashMap（请参阅 CacheBuilder.newBuilder().softKeys()），但这可能不是您想要的，正如 Java 专家 Jeremy Manson 所解释的那样（如下）你会找到链接）。

---

不是我知道的（2008 年 11 月），但你会发现一些SoftHashMap 在网络上的实现。

就像这个： SoftHashMap或这个。

---

编辑（2009 年 11 月）
正如 Matthias 在评论中提到的，Google Guava MapMaker 确实使用了软引用：

ConcurrentMap 构建器，提供以下功能的任意组合：

• 软键或弱键，

• 软值或弱值、
• 定时到期以及
• 值的按需计算。

正如此帖子中提到的，另一个 JSR166y 候选者：

jsr166y.ConcurrentReferenceHashMap

它为 Google 实现提供了另一种并发参考映射（依赖后台线程来逐出条目）

---

编辑（2012 年 8 月）

Google 实现仅在请求条目定时过期时才使用后台线程。 特别是，它只是使用 java.util.Timer，这不像拥有单独的后台线程那样具有侵入性。

Jeremy Manson 建议，对于任何缓存，使用此功能来避免 SoftReference 的危险：
http://jeremymanson.blogspot.de/2009/ 07/how-hotspot-decides-to-clear_07.html

还有一个来自 Apache Commons，即 org.apache.commons.collections.map.ReferenceMap; 它不支持定时删除，但它支持选择是否应按同一性或相等性比较键。 此外，此实现不是并发的 - 它可以同步，但在多个线程访问的情况下效果较差。

Answer 2

我熟悉两个提供 SoftHashMap 实现的库：

1. Apache Commons：org.apache。 commons.collections.map.ReferenceMap

2. Google 集合：com.google.common.collect.ReferenceMap

Answer 3

98期java专家通讯中有一个示例实现

Answer 4

Apache Shiro 附带了一个专为缓存设计的 SoftHashMap。 它基于上面 jb 发布的文章，并在 Apache v2 下获得许可。 您可以在此处找到文档和源代码此处。

Answer 5

您是否考虑过使用 LRUMap 而不是软 HashMap？ 您可以更好地控制存储的内容（或至少存储多少）。

Answer 6

如果您想实现缓存，软引用肯定比弱引用更好，但它会将整个缓存删除策略交给垃圾收集器。 这可能不是你想要的。

如果缓存删除策略很重要，您将需要自己执行此操作，很可能使用常规引用。 但是，您必须决定何时弹出项目以及弹出哪些项目。 如果您只想在堆空间耗尽时丢失一些东西，您可以通过以下方式查询可用的堆空间：

Runtime.getRuntime().getFreeMemory();

然后，一旦可用内存下降到一定数量以下，您就可以开始删除项目。 或者您可以只实现缓存的最大大小，并使用它来决定何时删除内容。

这是我设计的LRU缓存插入、删除和查找时间为 O(1)，具有可配置的最大元素数量。 如果你想要一个缓存，恕我直言，这将是比 SoftHashMap 更好的解决方案。

软引用是创建可增长缓存的好方法。 因此，理想的解决方案是使用 SoftHashMap 以及常规的固定大小缓存。 让所有到缓存的插入都进入固定缓存和软哈希映射，然后引用某些东西，看看它是否在软哈希映射中（并更新缓存中的引用时间）。 这样，您所有最重要的项目（根据您选择的策略 LRU、MFU 等）将永远不会被删除，因为它们在缓存中被硬引用，但您也将保留更多的东西（没有策略控制）因为有足够的内存。

Answer 7

例如，您可以使用此实现线程安全的软引用 HashMap：

package cz.b2b.jcl.util;

import java.util.*;
import java.lang.ref.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.AbstractMap.SimpleImmutableEntry;

public class ConcurrentSoftHashMap<K, V> extends AbstractMap {

    /**
     The internal HashMap that will hold the SoftReference.
     */
    private final Map<Object, SoftReference> hash = new ConcurrentHashMap<>();
    /**
     The number of "hard" references to hold internally.
     */
    private final int HARD_SIZE;
    /**
     The FIFO list of hard references, order of last access.
     */
    private final ConcurrentLinkedSetQueue hardCache = new ConcurrentLinkedSetQueue();
    /**
     Reference queue for cleared SoftReference objects.
     */
    private final ReferenceQueue queue = new ReferenceQueue();

    public ConcurrentSoftHashMap(int hardSize) {
        HARD_SIZE = hardSize;
    }

    @Override
    public Object get(Object key) {
        Object result = null;
        // We get the SoftReference represented by that key
        SoftReference soft_ref = hash.get(key);
        if (soft_ref != null) {
            // From the SoftReference we get the value, which can be
            // null if it was not in the map, or it was removed in
            // the processQueue() method defined below
            result = soft_ref.get();
            if (result == null) {
                // If the value has been garbage collected, remove the
                // entry from the HashMap.
                hash.remove(key);
            } else {
                // We now add this object to the beginning of the hard
                // reference queue.  
                hardCache.enqueue(result);
                if (hardCache.size() > HARD_SIZE) {
                    // Remove the last entry if list longer than HARD_SIZE
                    hardCache.dequeue();
                }
            }
        }
        return result;
    }

    /**
     Here we put the key, value pair into the HashMap using
     a SoftValue object.
     @param key
     @param value
     @return
     */
    @Override
    public Object put(Object key, Object value) {
        processQueue(); // throw out garbage collected values first
        return hash.put(key, new SoftValue(value, key, queue));
    }

    @Override
    public Object remove(Object key) {
        processQueue(); // throw out garbage collected values first
        return hash.remove(key);
    }

    @Override
    public void clear() {
        hardCache.clear();
        processQueue(); // throw out garbage collected values
        hash.clear();
    }

    @Override
    public int size() {
        processQueue(); // throw out garbage collected values first
        return hash.size();
    }

    @Override
    public boolean containsKey(Object key) {
        processQueue(); // throw out garbage collected values first
        return hash.containsKey(key);
    }

    @Override
    public Set entrySet() {
        Set<Map.Entry> entry = new HashSet<>();
        Map.Entry simpleImmutableEntry = null;
        Object result = null;
        processQueue(); // throw out garbage collected values first
        for (Map.Entry<Object, SoftReference> item : hash.entrySet()) {
            if (item == null) {
                continue;
            }
            Object key = item.getKey();
            SoftReference soft_ref = item.getValue();
            if (soft_ref != null) {
                result = soft_ref.get();
                if (result == null) {
                    hash.remove(key);
                } else {
                    hardCache.enqueue(result);
                    if (hardCache.size() > HARD_SIZE) {
                        hardCache.dequeue();
                    }
                    simpleImmutableEntry = new SimpleImmutableEntry(key, result);
                    entry.add(simpleImmutableEntry);

                }
            }

        }

        return entry;
    }

    private class ConcurrentLinkedSetQueue<E> extends ConcurrentLinkedQueue<E> {

        public void enqueue(E o) {
            if (!contains(o)) {
                add(o);
            }
        }

        public E dequeue() {
            return poll();
        }

    }

    /**
     We define our own subclass of SoftReference which contains
     not only the value but also the key to make it easier to find
     the entry in the HashMap after it's been garbage collected.
     */
    private static class SoftValue extends SoftReference {

        private final Object key; // always make data member final

        /**
         Did you know that an outer class can access private data
         members and methods of an inner class? I didn't know that!
         I thought it was only the inner class who could access the
         outer class's private information. An outer class can also
         access private members of an inner class inside its inner
         class.
         */
        private SoftValue(Object k, Object key, ReferenceQueue q) {
            super(k, q);
            this.key = key;
        }
    }

    /**
     Here we go through the ReferenceQueue and remove garbage
     collected SoftValue objects from the HashMap by looking them
     up using the SoftValue.key data member.
     */
    private void processQueue() {
        SoftValue sv;
        while ((sv = (SoftValue) queue.poll()) != null) {
            hash.remove(sv.key); // we can access private data!
        }
    }

}