如何实现 LRU 缓存机制
1. 场景与原理
场景:
设计一种缓存,要求总是能够快速访问最新的数据,并且查找与删除时间和空间复杂度都是尽可能低;
方法:哈希表 + 双向链表。
时间复杂度:对于 put 和 get 都是 O(1)。
空间复杂度:O(capacity),因为哈希表和双向链表最多存储 capacity+1 个元素。
为什么要有LRU?
- 在计算机存储层次结构中,低一层的存储器都可以看做是高一层的缓存。比如Cache是内存的缓存,内存是硬盘的缓存,硬盘是网络的缓存等等。
- 缓存可以有效地解决存储器性能与容量的这对矛盾,但绝非看上去那么简单。如果缓存算法设计不当,非但不能提高访问速度,反而会使系统变得更慢。
- 从本质上来说,缓存之所以有效是因为程序和数据的局部性(locality)。程序会按固定的顺序执行,数据会存放在连续的内存空间并反复读写。这些特点使得我们可以缓存那些经常用到的数据,从而提高读写速度。
- 缓存的大小是固定的,它应该只保存最常被访问的那些数据。然而未来不可预知,我们只能从过去的访问序列做预测,于是就有了各种各样的缓存替换策略。本文介绍一种简单的缓存策略,称为最近最少使用(LRU,Least Recently Used)算法。
总结来说:计算机读取文件(数据库)的速度相对于读取内存的数据来说,效率要低得多,因此常用缓存来提高访问效率,而内存相比较于硬盘要小的多,为了缓存更有价值的数据,淘汰算法就显得尤为重要。
如何实现 LRU 缓存机制
https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247484500&idx=1&sn=83f4df1253f597898b2f74ea9dca9fd9&chksm=9bd7fa5caca0734ad182ba67651882647a71264938eaa98e49c5ff43369b807a094ad16efcd4&scene=21#wechat_redirect
详细代码实现:
https://github.com/labuladong/yueduyuanwen/blob/master/LRUcache/lru-cache.java
原理机制:LRU 缓存淘汰算法就是一种常用策略。LRU 的全称是 Least Recently Used,也就是说我们认为最近使用过的数据应该是是「有用的」,很久都没用过的数据应该是无用的,缓存满了就优先删那些很久没用过的数据。
实现思路:
- 新数据插入到链表头部;
- 每当缓存命中(即缓存数据被访问),则将数据移到链表头部;
- 当链表满的时候,将链表尾部的数据丢弃。
提示:Java里面实现LRU缓存通常有两种选择,一种是使用LinkedHashMap,一种是自己设计数据结构,使用链表+HashMap;
(其中LinkedHashMap改造查看链接:https://www.cnblogs.com/lzrabbit/p/3734850.html)
如下是缓存淘汰过程示意图:
2. LRU机制的实现过程
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;
}
public void addFirst(Node x) {
x.next = head.next;
x.prev = head;
head.next.prev = x;
head.next = x;
size++;
}
public void remove(Node x) {
x.prev.next = x.next;
x.next.prev = x.prev;
size--;
}
public Node removeLast() {
if (tail.prev == head)
return null;
Node last = tail.prev;
remove(last);
return last;
}
public int size() { return size; }
}
class LRUCache {
private int cap;
private HashMap<Integer, Node> map;
private DoubleList cache;
public LRUCache(int capacity) {
// 初始化 LRU cache 的数据
this.cap = capacity;
map = new HashMap<>();
cache = new DoubleList();
}
public int get(int key) {
if (!map.containsKey(key))
return -1;
int val = map.get(key).val;
put(key, val);
return val;
}
public void put(int key, int val) {
// 先把新节点 x 做出来
Node x = new Node(key, val);
if (map.containsKey(key)) {
// 删除旧的,新的插到头部
cache.remove(map.get(key));
cache.addFirst(x);
// 更新 map 中对应的数据
map.put(key, x);
} else {
if (cap == cache.size()) {
// 删除链表最后一个
Node last = cache.removeLast();
map.remove(last.key);
}
// 直接添加到头部即可
cache.addFirst(x);
map.put(key, x);
}
}
}
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache obj = new LRUCache(capacity);
* int param_1 = obj.get(key);
* obj.put(key,value);
*/
3.调用该LRU缓存的过程
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache obj = new LRUCache(capacity);
* int param_1 = obj.get(key);
* obj.put(key,value);
*/
public class LRUTestMain {
public static void main(String[] args) {
final LRUCache lruCache = new LRUCache(2);
lruCache.put(1, 11);
lruCache.put(2, 22);
lruCache.put(3, 33);
//容量为2,当插入3时候,1的结果被淘汰;因此此处返回结果为-1;
System.out.println(lruCache.get(1));
System.out.println(lruCache.get(2));
System.out.println(lruCache.get(3));
}
}
该算法的时间复杂度是O(1),空间复杂度是O(1)
优缺点:
【命中率】
当存在热点数据时,LRU的效率很好,但偶发性的、周期性的批量操作会导致LRU命中率急剧下降,缓存污染情况比较严重。
【复杂度】
实现简单。
【代价】
命中时需要遍历链表,找到命中的数据块索引,然后需要将数据移到头部。
改进:
针对缓存污染问题,后期有对应的对LRU的改进:
https://www.cnblogs.com/Dhouse/p/8615481.html
- LRU-K
- Two queues(2Q)
- Multi Queue(MQ)