LinkedHashMap：我还能实现LRU

众所周知，LinkedHashMap继承自HashMap，在原先的HashMap的基础上，它增加了Entry的双向链接。

有意思的是基于这种实现特性，LinkedHashMap 在迭代遍历时，取得键值对的顺序的依据是其插入次序或者是最近最少使用（LRU）的次序。

LRU算法根据数据的历史访问记录来淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”，从而实现在定量缓存空间下缓存内容的管理，常用于浏览器和移动端各应用等本地缓存管理。

通过access方式创建LinkedHashMap即可实现基本的LRU算法，可看源码中LinkedHashMap的构造函数：

/**
     * Constructs an empty <tt>LinkedHashMap</tt> instance with the
     * specified initial capacity, load factor and ordering mode.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @param  accessOrder     the ordering mode - <tt>true</tt> for
     *         access-order, <tt>false</tt> for insertion-order
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

　　查看源码可知，其中LinkedHashMap的取得键值对的顺序是由其构造函数中传入的第三个参数accessOrder决定，当其为false时，即为选用插入次序；为true时，即为选用LRU的次序。

而在我们利用LinkedHashMap实现LRU的关键在于重写下面这个方法

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

　　下面我就使用LinkedHashMap实现LRU做了两个test。

　　第一个test的目的是为了验证LinkedHashMap实现LRU的可行性，即其根据访问时间来管理内部元素的排序，具体实现如下：

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class Test {

    public static void main(String[] args) {

        Map<Integer,Integer> map = new LinkedHashMap<>(16,0.75f,true);
        for(int i=0;i<16;i++)
            map.put(i, i);
        for(Iterator<Map.Entry<Integer, Integer>> iterator=map.entrySet().iterator();iterator.hasNext();) {
            System.out.print(iterator.next().getKey()+" ");
        }
        System.out.println();
        map.get(5);
        for(Iterator<Map.Entry<Integer, Integer>> iterator=map.entrySet().iterator();iterator.hasNext();) {
            System.out.print(iterator.next().getKey()+" ");
        }
    }

}　

输出情况如下：

可见访问过的5确实被放到链表的末尾。

第二个test即是一个简单的实现LRU功能的LinkedHashMap,直接贴代码：

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{
    private int capacity;
    private static final long serialVersionUID=1L;
    /**
     * LRULinkedHashMap的含参构造器
     * @param capacity 指定的缓存最大容量
     */
    LRULinkedHashMap(int capacity){
        super(16,0.75f,true);
        this.capacity=capacity;
    }

    @Override
    /**
     * 当map中存储元素大于了最大缓存容量时，删除链表顶端元素即最近最少使用元素。
     * 输出当前最少使用的元素的键值对
     */
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        // TODO 自动生成的方法存根
        System.out.println("("+eldest.getKey()+"，"+eldest.getValue()+")");
        return size()>capacity;
    }

}

public class LinkedHashMapForLRU {
    public static void main(String[] args) {
        Map<Integer, Integer>  map = new LRULinkedHashMap<Integer,Integer>(5);
        //存入7个键值对
        for(int i=0;i<7;i++)
            map.put(i, i);
        //输出最后保存在缓存中的键值对
        for(Iterator<Map.Entry<Integer,Integer>> it = map.entrySet().iterator();it.hasNext();) {
            System.out.print(it.next().getKey()+" ");
        }

    }
}

输出情况如下：

可见我们实现的LRULinkedHashMap确实发挥了它的作用。

那LinkedHashMap在源码中是怎么实现LRU算法的呢？

接下来从Map的初始化构造、put、get这三个方面结合源码展开

初始化构造函数：

初始化构造在前面已经提到过，这里直接贴上LinkedHashMap的几个构造函数

public LinkedHashMap() {
        super();
        accessOrder = false;
    }

　　构造一个以插入顺序排序的空LinkedHashMap，，其默认初始容量为16，并且负载系数为0.75

public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

　　构造一个以插入顺序排序的空LinkedHashMap，，其负载系数为0.75，根据传入的参数参数决定其初始容量

 public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

　　构建一个以插入顺序排序的空LinkedHashMap，根据传入的参数决定其初始容量和负载系数。

 public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

　　构建一个空LinkedHashMap，根据传入的参数决定其初始容量、负载系统及排序方式。

public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }

　　而最后这种构造函数则是构建一个指定Map的LinkedHashMap，默认负载系统为0.75，而初始容量则足够容纳指定的Map。

Put：

通过查看源码发现LinkedHashMap并没有重写父类HashMap的put方法，下面我们先看一下HashMap的put方法。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

　　发现它调用了putVal(hash(key), key, value, false, true)，下面的即是其调用的putVal方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

其中调用了两个关键的方法

 void afterNodeAccess(Node<K,V> p)和 void afterNodeInsertion(boolean evict)，而这两个方法实现关于插入节点和节点访问的细节，

void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }

 void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }

从   if (evict && (first = head) != null && removeEldestEntry(first))  ，我们就能看到了调用了  removeEldestEntry(first)。即当该方法返回为真时，会调用方法来删除链表头。

而另一个重要的方法afterNodeAccess()则完成了在每一次节点访问后节点顺序的管理，想必这个方法会在get()方法中得到调用，下面我们就来看一下get()方法。

get()：

LinkedHashMap重写了get()方法和getOrDefault()方法。

public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

 public V getOrDefault(Object key, V defaultValue) {
       Node<K,V> e;
       if ((e = getNode(hash(key), key)) == null)
           return defaultValue;
       if (accessOrder)
           afterNodeAccess(e);
       return e.value;
   }

对比HashMap中的get()

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

这里添加了对accessOrder的判断，即当为LRU模式下，会调用afterNodeAccess();这个方法会管理链表的排序，将最近访问过的结点放到链表末尾。

到这里我们应该基本上理清了LinkedHashMap对LRU算法的支持的实现手段。

即通过构造函数中的accessOrder参数来选择建Map模式，通过 afterNodeAccess(Node<K,V> p)在结点被访问后的顺序管理，

afterNodeInsertion(boolean evict)方法实现结点插入后，根据removeEldestEntry(first)的返回结果来进行结点的删除操作。

后记：

当然直接继承LinkedHashMap来实现LRU，在多线程环境下极有可能会出现问题，因为LinkedHashMap不是一个线程安全的容器，所以如果我们想要基于这种容器实现并发环境下的LRU的话，需要增加线程同步的处理。

其中一种处理方式是调用Collections.synchronizedMap()。

而另外一种方法不通过继承来重写LinkedHashMap，而是通过组合的方式实现，并且对map的get()、put()、remove()、size()等操作进行加锁（synchronized），或者在此基础上进行同步上的优化。