LRU缓存的实现

文章目录

• LRU简介
• LRU算法分析
• 实现代码
• • 节点类
  • 双向链表
  • LRUCache类
  • 测试类
• 总结

---

LRU简介

LRU是“Least Recently Used”的简写，意思是最近最少使用，是一种缓存淘汰策略，在有限的缓存资源中，淘汰掉最近最久未使用的。例如：缓存最大容纳10000条数据，在添加时，只要数据总数小于等于10000可以随意添加，但是当数据量大于1万时，将旧的数据删除，再添加新的数据；添加时，要将新来的数据添加到最前面。说完来添加，再来说查询，从缓存中获取的数据返回之前，需要将数据移动到最前面，因为获取改数据就代表最近使用了，对于缓存来说，最近这个数据很有可能会被再次使用，所以要移动到最前面。

---

LRU算法分析

因为缓存具有查询快（时间复杂度必须是O(1)），增加快，删除快的特点。同时，LRU策略分析的数据有新旧之分，新的在最前面，旧的往后放。因此选取数据结构时，要遵循有序的特点。因此可以将HashMap与双向链表结合起来实现LRUCache。Hash表查询效率是O(1)，但是不是有序的，双向链表（此处不是循环链表）有序并且增加与删除都是O(1)，但查询是O(n)，所以两者互相取长补短。

实现代码

节点类

public class Node {
    public int key,value;
    public Node prev;
    public Node next;

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Node{" +
                "key=" + key +
                ", value=" + value +
                '}';
    }
}

双向链表

public class DoubleList {
    private LinkedList<Node> linkedList = new LinkedList();

    /**添加第一个节点
     * @param node
     */
    public void addFirst(Node node){
        linkedList.addFirst(node);
    }

    /**
     *移除最后一个节点
     */
    public Node removeLast(){
        return linkedList.removeLast();
    }

    /**
     *移除节点
     */
    public void remove(Node node){
        linkedList.remove(node);
    }

    /**
     *  链表长度
     * @return
     */
    public int size(){
        return linkedList.size();
    }

    /**
     * 输出双向链表
     */
    public void printAll(){
        Iterator<Node> iterator = linkedList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

LRUCache类

public class LRUCache {
    private HashMap<Integer, Node> map;
    private DoubleList cache;
    private int cap;

    public LRUCache( int cap) {
        this.map = new HashMap<Integer, Node>();
        this.cache = new DoubleList();
        this.cap = cap;
    }

	/**
	 * 查询value
	 **/
    public int get(int key){
        // 首先判断key是否在map中
        if (map.containsKey(key)){
            int x = map.get(key).value;
            // 在返回之前，将最近访问的键值对添加到LRU中
            put(key,x);
            return x;
        }else {
            // 不存在返回-1
            return -1;
        }
    }

	// 新增键值对
    public void put(int key,int value){
        Node node = new Node(key, value);
        // 首先判断key是否在map中,如果已存在,map直接新增，覆盖旧的value
        if (map.containsKey(key)){
            // 链表中删除旧的节点，在头部添加新的节点
            cache.remove(map.get(key));
            cache.addFirst(node);
            map.put(key,node);

        }else{
            // 在向LRU添加key时，如果缓存已满，要删除最后一个Node,同时map中也要记得删除该key
            if (cache.size()==cap){
                Node last = cache.removeLast();
                map.remove(last.key);
            }
            cache.addFirst(node);
            map.put(key,node);
        }

    }

	// 输出缓存中的数据
   public void listAll(){
        cache.printAll();
   }

}

测试类

class LRUCacheTest {
    private LRUCache lruCache = new LRUCache(4);

    @Test
    public void LRUCacheTest() {
        lruCache.put(1, 2);
        lruCache.put(2, 3);
        lruCache.put(3, 4);
        lruCache.put(5, 6);
        // 因为cache大小是4，再添加新的数据时，会将最早加入缓存的数据淘汰掉
        lruCache.put(6, 67);
        // 获取第二次添加的数据，获取后(2,3)会被移动到最前边
        lruCache.get(2);
        lruCache.listAll();
    }

}

所以输出结果：

总结

对于LRU算法，他的优势在于对热点数据的查询，使用LRU可以有效提高查询效率，但是对于批量查询历史数据，有可能导致缓存污染，偶然的查询历史数据，会覆盖掉热点数据，导致本次查询不再走缓存。