LinkedHashMap实现本地缓存

【--亲测有效--】

转载出处：https://coderxing.gitbooks.io/architecture-evolution/di-er-pian-ff1a-feng-kuang-yuan-shi-ren/42-xing-neng-zhi-ben-di-huan-cun/421-ying-yong-ceng-ben-di-huan-cun/4211.html

在 Java 中使用本地缓存最简单的方式就是使 HashMap 或者 ConcurrentHashMap，对于只读场景，两者都可以使用，对于缓存更新的场景，可以使用 ConcurrentHashMap 来保证数据的一致性，二者的使用方式非常简单，这里不再赘述。

+

​ 另外，在 Java 中基于 LinkedHashMap 类，提供了一个自动清理最老元素的功能，，基于这个特质，可以将改造成一个LRU（Least Recently Used ，表示最近最少使用）缓存使用。

​ 将 LinkedHashMap 改造成缓存，需要重写 LinkedHashMap 中 removeEldestEntry(Map.Entry<K,V> eldest)，这个方法，改方法是 protected 方法，不能直接调用，只能继承重写。当插入数据时（调用 put 或者 putAll 时）会调用这个方法用于判断是否移除最老元素，返回 true 表示删除，否则不删除，Java 源代码中，该方法直接返回 false，如下图所示，看来是专门留给开发者扩展额。

案例代码如下：

package com.github.coderxing.book.code.chapter4;

public class LruCache<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = 4504158311663914052L;

    private int maxCacheSize;

    public LruCache(int maxCacheSize) {

        // 第三个参数为 accessOrder，默认为false。表示按照按照访问顺序排列元素，最近访问的元素会排雷在队末尾

        super(maxCacheSize, 0.75f, true);

        this.maxCacheSize = maxCacheSize;

    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {

        // 当达到预设缓存上限时删除最老元素
        return this.size() >= maxCacheSize + 1;
    }


}

测试代码如下：

LruCache<String, String> cache = new LruCache<String, String>(3);

cache.put("k1", "v1");

System.out.println("test1:"+cache);

cache.put("k2", "v2");

System.out.println("test2:"+cache);

cache.put("k3", "v3");

System.out.println("test3:"+cache);

cache.put("k4", "v4");

System.out.println("test4:"+cache);

//因为我们在后再对象时，accessOrder设置为true，访问一次 k2，k2对应的元素就会排在队尾部，被看做最新元素

cache.get("k2");

System.out.println("test5:"+cache);


Map<String,String> multiKV = new HashMap<String,String>();

multiKV.put("k5", "k5");

multiKV.put("k6", "k6");

cache.putAll(multiKV);

System.out.println("test5:"+cache);

输出内容为：

test1:{k1=v1}

test2:{k1=v1, k2=v2}

test3:{k1=v1, k2=v2, k3=v3}

test4:{k2=v2, k3=v3, k4=v4}

test5:{k3=v3, k4=v4, k2=v2}

test5:{k2=v2, k5=k5, k6=k6}

​ 从例子中可见，通过简单的方式就可以快速实现一个LRU缓存类，但 LinkedHashMap 不是线程安全额，在面对高并发的情况下还需要进一步封装，比如通过 synchronized 封装代理方法，如：

public V putCache(K key, V value) {
  synchronized(this){
    return this.put(key, value);
  }
}

或者 Collections.synchronizedMap 进行封装，例如：

```java

Map<String, String> cache = Collections.synchronizedMap(new LruCache<String, String>(3));

```

​ 使用 LinkedHashMap 可以简单快速实现一个缓存框架，要想获得更好的性能，和更强大的功能，可以参考本周后面两节介绍的 Ehcache 和 Google Guava Cache 。