LRU Java两种简单实现

LRU Java两种简单实现

​ LRU即Least Recently Used ，最近最少使用的缓存替换规则，此缓存策略关注于程序访问存储介质两个性质之一：时间局部性，最近访问到的内容，接下来大概率会继续访问到。LRU的实现不难，且在java中还有现成的代码可以使用以及学习。下面给出两种LRU的实现：

1.持有或继承LinkedHashMap

​ LinkedHashMap在HashMap平均O(1)的访问基础上，存储的节点额外增加了前后指向关系：

    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

​ 注：HashMap中的冲突链表转化为红黑树后，红黑树的node是继承了Entry的，所以也具备该前后指向关系

​ LinkedHashMap有head、tail成员变量，用于指向前后关系的头和尾。在LinkedHashMap中有个布尔的变量accessOrder，当为true时，此时前后的顺序为访问的时间顺序，为false时，记录的是插入的时间顺序，所以要做LRU缓存的话，需要设置为true。LinkedHashMap在插入和获取时，会调整元素的位置，调整到最新的位置上，即tail变量。这里的head和tail指向关系有点反常识，head指向的是最老的元素，tail指向的是最新的元素。

​ LinkedHashMap要实现缓存的关键点是重写removeEldestEntry方法，这是移除规则的实现方法，默认实现中是直接返回的false。比较简单的实现是判断当前存放元素的size是否达到的初始设置的容量，如果达到了就移除最久未使用的元素。

​ 完成实现如下：

public class  LRUCache_146 extends LinkedHashMap<Integer,Integer> {
    private int capacity;

    public LRUCache_146(int initialCapacity) {
        super(initialCapacity, 0.75f, true);
        this.capacity=initialCapacity;
    }
    
    public int get(int key) {
        return super.getOrDefault(key,-1);
    }

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

    public void put(int key, int value) {
        super.put(key, value);
    }
}

​ 这个是继承的实现，持有一个LinkedHashMap的写法类似。

2.自行实现时间的前后关系

​ 在前面的第一种实现里，时间的顺序是由LinkedHashMap维护的，在这个实现里面，自行维护时间顺序，不过在hash映射上依然使用HashMap的能力。

​ 在实现之前，应该大致捋一下里面可能涉及到的变量、方法，有个大致的思路，写起来会清晰很多，笔者抽取的要点如下：

​ a.三个成员变量：head（指向最年轻的元素）、tail（指向最年老的元素）、capacity（存储的最大容量）

​ b.当新增元素或者获取已有元素时，元素需插入到head头，即insert2Head方法

​ c.当获取已有元素时，元素需要断开原前后指向关系，并插入到head头，即move2Head方法

​ d.当容量满了时，需要移除最老的元素，即removeLastUsed方法

​ 当然存储的元素entry得有前后的指向关系，即pre和next属性。

完成实现如下：

/**
 * 最近最少使用的缓存
 */
public class LRUCache {

    Map<Integer, Entry> cache;
    Entry head, tail;
    int capacity;

    public LRUCache(int capcity) {
        this.capacity = capcity;
        cache = new HashMap<>();
    }

    public int get(int key) {
        Entry entry = cache.get(key);
        if (entry == null) {
            return -1;
        }
        //调整位置，移动到头部
        move2Head(entry);
        return entry.val;
    }

    public void put(int key, int value) {
        Entry entry = cache.get(key);
        if (entry != null) {
            //修改val并调整位置到头部
            entry.val = value;
            move2Head(entry);
        } else {
            //超过容量，移除一个最近最久未使用的元素
            if (cache.size() == capacity) {
                removeLastestUsed();
            }
            entry = new Entry(key, value);
            cache.put(key, entry);
            insert2Head(entry);
        }
    }

    /**
     * 移除最近最久未使用的元素
     */
    private void removeLastUsed() {
        if (tail == null) {
            return;
        }
        cache.remove(tail.key);
        if (tail == head) {
            tail = null;
            head = null;
            return;
        }
        Entry pre = tail.pre;
        pre.next = null;
        tail.pre = null;
        tail = pre;
    }

    /**
     * 将元素移动到头部，只对已存在的entry操作
     *
     * @param entry
     */
    private void move2Head(Entry entry) {
        Entry pre = entry.pre;
        Entry next = entry.next;
        if (pre == null) {
            //说明是head节点，不用继续操作
            return;
        }
        if (next == null) {
            //说明是尾节点，需要更改tail的指向
            pre.next = null;
            entry.pre = null;
            tail = pre;
            insert2Head(entry);
            return;
        }
        pre.next = next;
        next.pre = pre;
        insert2Head(entry);
    }

    private void insert2Head(Entry entry) {
        if (tail == null && head == null) {
            head = entry;
            tail = entry;
            return;
        }
        Entry head = this.head;
        entry.next = head;
        entry.pre = null;
        head.pre = entry;
        this.head = entry;
    }


    private static class Entry {
        int key;
        int val;
        Entry pre;
        Entry next;

        public Entry(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }
}

其实更狠的是，Hash映射也自己实现，这里先留一个坑位，待后面把Hash映射实现了，再把链接放在这里。