LinkedHashMap实现本地缓存

落日映苍穹つ 2022-05-16 15:54 301阅读 0赞

【--**亲测有效**\--】

转载出处：[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][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，如下图所示，看来是专门留给开发者扩展额。

![5F751099-797F-47E7-B1CC-986393161D96.png][]

案例代码如下：

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 。

[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]: 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
[5F751099-797F-47E7-B1CC-986393161D96.png]: https://coderxing.gitbooks.io/architecture-evolution/assets/5F751099-797F-47E7-B1CC-986393161D96.png