LRU算法及Java实现

LRU算法简介

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

方法一，使用hashmap

1. 在O（1）时间内操作对应的key|value，应该考虑到使用hashmap；
2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
3. 当链表满的时候，将链表尾部的数据丢弃。

//用HashMap和一个双向链表来实现LRU缓存

class LRUCache {

    // 双向链表节点定义
    class Node {
        int key;
        int val;
        Node prev;
        Node next;
    }
    
    private int capacity;
    //保存链表的头节点和尾节点
    private Node first;
    private Node last;
    
    private Map<Integer, Node> map;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>(capacity);
    }
    
    public int get(int key) {
        Node node = map.get(key);
        //为空返回-1
        if (node == null) {
            return -1;
        }
        moveToHead(node);
        return node.val;
    }
    
    private void moveToHead(Node node) {
        if (node == first) {
            return;
        } else if (node == last) {
            last.prev.next = null;
            last = last.prev;
        } else {
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }
        
        node.prev = first.prev;
        node.next = first;
        first.prev = node;
        first = node;
    }
    
    public void put(int key, int value) {
        Node node = map.get(key);
        
        if (node == null) {
            node = new Node();
            node.key = key;
            node.val = value;
            
            if(map.size() == capacity) {
                removeLast();
            }
            
            addToHead(node);
            map.put(key, node);
        } else {
            node.val = value;
            moveToHead(node);
        }
    }
    
    private void addToHead(Node node) {
        if (map.isEmpty()) {
            first = node;
            last = node;
        } else {
            node.next = first;
            first.prev = node;
            first = node;
        }
    }
    
    private void removeLast() {
        map.remove(last.key);
        Node prevNode = last.prev;
        if (prevNode != null) {
            prevNode.next = null;
            last = prevNode;
        }
    }
    
    @Override
    public String toString() {
    	return map.keySet().toString();
    }
    
    public static void main(String[] args) {
    	LRUCache cache = new LRUCache(3);
        cache.put(1, 1);
        cache.put(2, 2);
        cache.put(3, 3);
        cache.get(1);
        cache.put(4, 3);
        System.out.println(cache);
	}
}

方法二，使用linkedhashmap

其实JDK已经为我们提供了一个基于HashMap和双向链表实现的数据结构，它就是LinkedHashMap，它内部维护的双向链表，可以帮助我们维护两种顺序：

• 插入顺序
• LRU顺序

下面简单的介绍下LinkedHashMap

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

它继承自HashMap，同样具有快速查找特性。

/**
 * The head (eldest) of the doubly linked list.
 */
transient LinkedHashMap.Entry<K,V> head;

/**
 * The tail (youngest) of the doubly linked list.
 */
transient LinkedHashMap.Entry<K,V> tail;

内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
另外根据注释，我们可以看出来，头节点head是最老的节点，而尾节点是最近一次被访问的节点，所以维护LRU顺序时，容量用完后，再执行新数据的插入的话，会移除头节点。

final boolean accessOrder;

accessOrder决定了维护的是哪一种顺序，默认为 false，此时维护的是插入顺序。为true时，维护的就是LRU顺序了。

void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }

LinkedHashMap 最重要的是上述这两个用于维护顺序的函数，它们会在 put、get 等方法中调用。

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;
    }
}

当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最少使用的节点。

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);
    }
}

在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最老的节点，也就是链表首部节点 first。

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

removeEldestEntry() 默认返回 false，如果需要让它为 true，需要继承 LinkedHashMap 并且重写这个方法，这是实现 LRU 缓存的关键，通过移除最近最少使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。

接下来我们基于JDK提供给我们的LinkedHashMap来实现LRU缓存

public class LRUCache<K,V> extends LinkedHashMap<K, V>{
	
	//首先设定最大缓存空间 MAX_ENTRIES 为 3；
	private static final int MAX_ENTRIES = 3;
	
	//之后使用LinkedHashMap的构造函数将 accessOrder设置为 true，开启 LRU顺序；
	public LRUCache() {
		super(MAX_ENTRIES, 0.75f, true);
	}
	
	//最后覆盖removeEldestEntry(）方法实现，在节点多于 MAX_ENTRIES 就会将最近最少使用的数据移除。
	//因为这个函数默认返回false，不重写的话缓存爆了的时候无法删除最近最久未使用的节点
	@Override
	protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
		//在容量超过最大允许节点数的时候返回true，使得在afterNodeInsertion函数中能执行removeNode()
		return size() > MAX_ENTRIES;
	}
	
	public static void main(String[] args) {
	    LRUCache<Integer, Integer> cache = new LRUCache<>();
	    cache.put(1, 1);
	    cache.put(2, 2);
	    cache.put(3, 3);
	    cache.get(1);
	    cache.put(4, 4);
	    System.out.println(cache.keySet());
	}
}

打印结果

[3, 1, 4]