Question

使这个自定义LinkedHashMap自定义缓存示例线程安全的最佳方法是什么？

 public class Cache extends LinkedHashMap<Object, Object>{
        private static final long serialVersionUID = -4297992703249995219L;
        private final int cacheSize;
        public Cache(int size){
            super(size + 1, .75f, true); 
            this.cacheSize=size;
        }

         protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
            return size() > cacheSize;
         }
    }


public class Main {
    public static void main(String[] args) {
        Cache cache = new Cache(2);
        cache.put(1, "one");
        cache.put(2, "two");

        for(Entry<Object, Object> entry : cache.entrySet()){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

Answer 1

我建议您在注释中遵循SLaks的建议，并使用并发库中的ConcurrentHashMap或其他数据结构，而不是尝试使非并发数据结构成为线程安全的更困难的任务。

一种解决方案是使用ConcurrentHashMap和ConcurrentLinkedQueue - 每当您向地图添加键值对时，也将其键添加到队列中，并轮询队列以删除最古老的地图条目一个潜在的复杂因素是你的线程的交错将导致一个对象在被添加到队列之前被添加到地图中 - 我不认为这是一个问题，因为你只需要队列的顺序来大致匹配将键值对添加到地图的顺序。

如果您希望能够在映射到期之前从映射中删除键值对，则此解决方案存在问题，因为您可能需要遍历整个队列以删除已从映射中删除的键。解决此问题的最简单方法是永远不要从队列中删除密钥，除非通过轮询它（即如果从地图中删除键值对，则不要从队列中删除密钥） - 你会有一些队列中的键与地图中的键不对应，但这只是一个问题，因为它会导致队列大于它需要的大小 - 地图的正确性不会受到影响。

Answer 2

我在这里有一个很复杂的答案，但后来我意识到它与说法完全相同：

Map<K,V> myMap = Collections.<K,V>synchronizedMap(new LinkedHashMap<K,V>());

myMap现在是一个线程安全的LinkedHashMap。无需创建新类。

Answer 3

ConcurrentHashMap与HashMap类非常相似，只是ConcurrentHashMap提供了内部维护的并发性。这意味着在多线程应用程序中访问ConcurrentHashMap时不需要具有同步块。

//Initialize ConcurrentHashMap instance
ConcurrentHashMap<String, Integer> m = new ConcurrentHashMap<String, Integer>();

//Print all values stored in ConcurrentHashMap instance
for each (Entry<String, Integer> e : m.entrySet())
{
system.out.println(e.getKey()+"="+e.getValue());
}

以上代码在您的应用程序的多线程环境中相当有效。我说“合理有效”的原因是，上面的代码还提供了线程安全性，但仍然会降低应用程序的性能。引入ConcurrentHashMap是为了在确保线程安全的同时提高性能。

为了提高性能，您可以根据需要调整以下参数：

参数：initialCapacity
loadFactor
concurrencyLevel

自定义LinkedHashMap并发

3 个答案: