LRU缓存机制

LRU缓存机制

LRU 缓存淘汰算法就是⼀种常⽤策略。LRU 的全称是 Least Recently Used，也就是说我们认为最近使⽤过的

数据应该是是「有⽤的」，很久都没⽤过的数据应该是⽆⽤的，内存满了就优先删那些很久没⽤过的数据。

一、LRU 算法怎么⼯作

/* 缓存容量为 2 */
LRUCache cache = new LRUCache(2);
// 你可以把 cache 理解成⼀个队列
// 假设左边是队头，右边是队尾
// 最近使⽤的排在队头，久未使⽤的排在队尾
// 圆括号表示键值对 (key, val)
cache.put(1, 1);
// cache = [(1, 1)]
cache.put(2, 2);
// cache = [(2, 2), (1, 1)]
cache.get(1); // 返回 1
// cache = [(1, 1), (2, 2)]
// 解释：因为最近访问了键 1，所以提前⾄队头
// 返回键 1 对应的值 1
cache.put(3, 3);
// cache = [(3, 3), (1, 1)]
// 解释：缓存容量已满，需要删除内容空出位置
// 优先删除久未使⽤的数据，也就是队尾的数据
// 然后把新的数据插⼊队头
cache.get(2); // 返回 -1 (未找到)
// cache = [(3, 3), (1, 1)]
// 解释：cache 中不存在键为 2 的数据
cache.put(1, 4); 
// cache = [(1, 4), (3, 3)]
// 解释：键 1 已存在，把原始值 1 覆盖为 4
// 不要忘了也要将键值对提前到队头

二、LRU 算法设计

分析上⾯的操作过程，要让 put 和 get ⽅法的时间复杂度为 O(1)，我们可以总结出 cache 这个数据结构必

要的条件：

1、显然 cache 中的元素必须有时序，以区分最近使⽤的和久未使⽤的数据，当容量满了之后要删除最久未

使⽤的那个元素腾位置。

2、我们要在 cache 中快速找某个 key 是否已存在并得到对应的 val；

3、每次访问 cache 中的某个 key，需要将这个元素变为最近使⽤的，也就是说 cache 要⽀持在任意位置快

速插⼊和删除元素。

那么，什么数据结构同时符合上述条件呢？哈希表查找快，但是数据⽆固定顺序；链表有顺序之分，插⼊删

除快，但是查找慢。所以结合⼀下，形成⼀种新的数据结构：哈希链表 LinkedHashMap。

LRU 缓存算法的核⼼数据结构就是哈希链表，双向链表和哈希表的结合体。这个数据结构⻓这样：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FRPSMO0Z-1638761598672)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20211206112436481.png)]

借助这个结构，我们来逐⼀分析上⾯的 3 个条件：

1、如果我们每次默认从链表尾部添加元素，那么显然越靠尾部的元素就是最近使⽤的，越靠头部的元素就是

最久未使⽤的。

2、对于某⼀个 key，我们可以通过哈希表快速定位到链表中的节点，从⽽取得对应 val。

3、链表显然是⽀持在任意位置快速插⼊和删除的，改改指针就⾏。只不过传统的链表⽆法按照索引快速访问

某⼀个位置的元素，⽽这⾥借助哈希表，可以通过 key 快速映射到任意⼀个链表节点，然后进⾏插⼊和删

除。

三、代码实现

class Node {
    public int key, val;
    public Node next, prev;
    public Node(int k, int v) {
    this.key = k;
    this.val = v;
    }
}


class DoubleList { 
     // 头尾虚节点
     private Node head, tail; 
     // 链表元素数
     private int size;

     public DoubleList() {
     // 初始化双向链表的数据
     head = new Node(0, 0);
     tail = new Node(0, 0);
     head.next = tail;
     tail.prev = head;
     size = 0;
     }
     // 在链表尾部添加节点 x，时间 O(1)
     public void addLast(Node x) {
     x.prev = tail.prev;
     x.next = tail;
     tail.prev.next = x;
     tail.prev = x;
     size++;
     }
     // 删除链表中的 x 节点（x ⼀定存在）
     // 由于是双链表且给的是⽬标 Node 节点，时间 O(1)
     public void remove(Node x) {
     x.prev.next = x.next;
     x.next.prev = x.prev;
     size--;
     }

     // 删除链表中第⼀个节点，并返回该节点，时间 O(1)
     public Node removeFirst() {
     if (head.next == tail)
     return null;
     Node first = head.next;
     remove(first);
     return first;
     }
     // 返回链表⻓度，时间 O(1)
     public int size() { return size; }
}

class LRUCache {
     // key -> Node(key, val)
     private HashMap<Integer, Node> map;
     // Node(k1, v1) <-> Node(k2, v2)...
     private DoubleList cache;
     // 最⼤容量
     private int cap;

     public LRUCache(int capacity) {
     this.cap = capacity;
     map = new HashMap<>();
     cache = new DoubleList();
     }
     
     /* 将某个 key 提升为最近使⽤的 */
     private void makeRecently(int key) {
     Node x = map.get(key);
     // 先从链表中删除这个节点
     cache.remove(x);
     // 重新插到队尾
     cache.addLast(x);
     }
     /* 添加最近使⽤的元素 */
     private void addRecently(int key, int val) {
         Node x = new Node(key, val);
         // 链表尾部就是最近使⽤的元素
         cache.addLast(x);
         // 别忘了在 map 中添加 key 的映射
         map.put(key, x);
     }
     /* 删除某⼀个 key */
     private void deleteKey(int key) {
         Node x = map.get(key);
         // 从链表中删除
         cache.remove(x);
         // 从 map 中删除
         map.remove(key);
     }
     /* 删除最久未使⽤的元素 */
     private void removeLeastRecently() {
         // 链表头部的第⼀个元素就是最久未使⽤的
         Node deletedNode = cache.removeFirst();
         // 同时别忘了从 map 中删除它的 key
         int deletedKey = deletedNode.key;
         map.remove(deletedKey);
     }

 }

以上是LRU机制的底层代码原理，我们可以使用java语言内置的LinkedHashMap来直接实现LRU：

class LRUCache {
 int cap;
 LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
 public LRUCache(int capacity) { 
 this.cap = capacity;
 }
 
 public int get(int key) {
 if (!cache.containsKey(key)) {
 return -1;
 }
 // 将 key 变为最近使⽤
 makeRecently(key);
 return cache.get(key);
 }
 
 public void put(int key, int val) {
 if (cache.containsKey(key)) {
 // 修改 key 的值
 cache.put(key, val);
 // 将 key 变为最近使⽤
 makeRecently(key);
 return;
 }
 
 if (cache.size() >= this.cap) {
 // 链表头部就是最久未使⽤的 key
 int oldestKey = cache.keySet().iterator().next();
 cache.remove(oldestKey);
 }
 // 将新的 key 添加链表尾部
 cache.put(key, val);
 }
 
 private void makeRecently(int key) {
 int val = cache.get(key);
 // 删除 key，重新插⼊到队尾
 cache.remove(key);
 cache.put(key, val);
 }
}

cache.remove(oldestKey);
}
// 将新的 key 添加链表尾部
cache.put(key, val);
}

private void makeRecently(int key) {
int val = cache.get(key);
// 删除 key，重新插⼊到队尾
cache.remove(key);
cache.put(key, val);
}
}