利用LinkHashMap实现LRU CACHE

LRU （Least Recently Used） 是一种缓存失效策略，即指定最大缓存 item 的数量，在缓存数量不足时将最近最少使用的缓存淘汰掉。

不失一般的，我们假定对缓存主要有两种操作：

1. PUT，即将数据放入缓存中；
2. GET，即尝试从缓存中获取数据。

以上两种操作都会被视为使用了缓存，当缓存空间不足时，将最近最少使用的数据从缓存中移除。使用 JAVA，我们应当如何实现以上的需求呢？

利用 HashMap 和 双向链表实现

思考上述需求后，可以有一个简单的解决思路：利用 HashMap 存储缓存数据，而后将数据节点组成一个双向链表，每次 PUT 或 GET 操作后都将操作涉及到的缓存数据节点插入链表的尾部，那么在缓存已满需要淘汰数据时就可以将链表头部指向的数据节点删除了。代码如下：

public class LRUCache {
    private int capacity;

    private Map> cacheData;

    private Node head;

    private Node tail;

    private static class Node {
        private K key;

        private V value;

        private Node pre;

        private Node next;

        private Node(K key, V value) {
            this.key = key;
            this.value = value;
        }


    }

    public LRUCache(int capacity) {

        if (capacity <= 0) {
            throw new InvalidParameterException("capacity 必须大于0");
        }

        this.capacity = capacity;

        //初始化 HashMap 大小为 capacity, 负载因子为 0.75
        this.cacheData = new HashMap<>(this.capacity, 0.75f);

        // sentinel 方便处理
        this.head = new Node<>(null, null);
        this.tail = new Node<>(null, null);

        this.head.next = this.tail;

        this.tail.pre = this.head;
    }

    public void put(K key, V value) {

        if (null == key) {
            throw new NullPointerException("key 不能为 null");
        }

        Node node = cacheData.get(key);
        //第一次 PUT 生成node
        if (null == node) {
            node = new Node<>(key, value);
        } else {
            deQueue(node);
        }

        //放入尾部
        putToTail(node);

        //是否需要淘汰数据
        removeLruIfNecessary();

        //放入缓存中
        cacheData.put(key, node);
    }

    /**
     * 删除最近最少使用的数据
     */
    private void removeLruIfNecessary() {
        if (cacheData.size() >= capacity) {
            Node remove = head.next;
            //从链表中移除
            deQueue(remove);
            cacheData.remove(remove.key);
        }
    }

    public V get(K key) {
        if (null == key) {
            throw new NullPointerException("key 不能为 null");
        }
        Node node = cacheData.get(key);
        if (null == node) {
            return null;
        }

        //从链表中移除
        deQueue(node);

        //加入链表尾部
        putToTail(node);

        return node.value;
    }


    private void deQueue(Node node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
        node.next = node.pre = null;
    }

    private void putToTail(Node node) {
        node.pre = tail.pre;
        node.next = tail;
        node.pre.next = node;
        tail.pre = node;
    }
}

进行简单的测试：

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache<>(10);

        for (int i = 0; i < 20; i++) {
            lruCache.put(i, i);
        }

        for (int j = 19; j >= 10; j--) {
            lruCache.get(j);
        }
    }

put(14,14)时

get(16)时

利用LinkedHashMap 实现

上面的实现其实还是有些复杂，其实 JDK 中的 LinkedHashMap 早就帮我们实现好了需要的功能。LinkedHashMap 是HashMap 的一个子类，保存了记录的插入顺序，在用 Iterator 遍历 LinkedHashMap 时，先得到的记录肯定是先插入的.也可以在构造时用带参数，按照应用次数排序。

使用 LinkedHashMap 构造 LRU cache的代码如下：

public class LRUCache {

    private LinkedHashMap linkedHashMap;

    public LRUCache(int capacity) {
        linkedHashMap = new LinkedHashMap(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {
                return size() > capacity;
            }
        };
    }

    public void put(K key, V value) {
        linkedHashMap.put(key, value);
    }

    public V get(K key) {
        return linkedHashMap.get(key);
    }
}

可以看到，只需要指定构造函数的 accessOrder 为true，再重写 LinkedHashMap 的 removeEldestEntry 方法，使其在容量超过预设大小时删除最老元素即可。