LRU介绍
LRU(Least Recently Used,最近最少使用)是一种常用的缓存淘汰算法,用于管理缓存中的数据。该算法的核心思想是根据数据的访问模式,淘汰最近最少被访问的数据,以便为新的数据让出空间。具体而言,LRU算法维护一个有序的数据结构,通常是一个双向链表,同时也使用哈希表来实现快速查找。
当数据被访问时,如果该数据已经在缓存中,则将其移动到链表的头部(表示最近被访问),保持最新访问的数据都在链表头部。如果新数据需要被加入缓存,但是缓存已满,则淘汰链表尾部的数据(表示最久未被访问),然后将新数据插入到链表头部。
LRU算法的优点是简单易实现,并且能够有效地反映数据的访问模式,从而提高缓存的命中率。然而,LRU算法也有一些缺点,例如需要维护额外的数据结构和开销较大的数据移动操作,以及无法完全适应某些特殊的访问模式,比如突发性的大量访问。
LRU工作原理
在这个示意图中,假设缓存的大小为5,并且当前缓存中存储了数据0、1、2、3、4,其中数据0在链表头部,数据4在链表尾部。
现在有一个新的数据5要加入缓存,因为缓存已满,需要淘汰最久未被访问的数据。根据LRU算法,需要淘汰链表尾部的数据4,并将数据5插入到链表头部,如下所示:
这样,缓存中最新访问的数据5被放在了链表的头部,而最久未被访问的数据4被淘汰了。
LRU根据JDK哈希实现
public class LRUCode extends LinkedHashMap<Integer,Integer> {
private int capacity;
public LRUCode(int capacity){
super(capacity,0.75F,true);
this.capacity=capacity;
}
public int get(int key){
return super.getOrDefault(key,-1);
}
public void put(int key,int val){
super.put(key,val);
}
protected boolean removeEldestEntry(Map.Entry<Integer,Integer> eldest) {
return size()>capacity;
}
}
LRU根据哈希和双向链表实现
LRU 缓存机制可以通过哈希表辅以双向链表实现,我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。
双向链表按照被使用的顺序存储了这些键值对,靠近头部的键值对是最近使用的,而靠近尾部的键值对是最久未使用的。
哈希表即为普通的哈希映射(HashMap),通过缓存数据的键映射到其在双向链表中的位置。
这样以来,我们首先使用哈希表进行定位,找出缓存项在双向链表中的位置,随后将其移动到双向链表的头部,即可在 O(1)O(1)O(1) 的时间内完成 get 或者 put 操作。具体的方法如下:
对于 get 操作,首先判断 key 是否存在:
如果 key 不存在,则返回 −1;
如果 key 存在,则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置,并将其移动到双向链表的头部,最后返回该节点的值。
对于 put 操作,首先判断 key 是否存在:
如果 key 不存在,使用 key 和 value 创建一个新的节点,在双向链表的头部添加该节点,并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量,如果超出容量,则删除双向链表的尾部节点,并删除哈希表中对应的项;
如果 key 存在,则与 get 操作类似,先通过哈希表定位,再将对应的节点的值更新为 value,并将该节点移到双向链表的头部。
public class LRUCache {
class DLinkedNode {
int key;
int value;
DLinkedNode prev;
DLinkedNode next;
public DLinkedNode() {}
public DLinkedNode(int _key, int _value) {key = _key; value = _value;}
}
private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
private int size;
private int capacity;
private DLinkedNode head, tail;
public LRUCache(int capacity) {
this.size = 0;
this.capacity = capacity;
// 使用伪头部和伪尾部节点
head = new DLinkedNode();
tail = new DLinkedNode();
head.next = tail;
tail.prev = head;
}
public int get(int key) {
DLinkedNode node = cache.get(key);
if (node == null) {
return -1;
}
// 如果 key 存在,先通过哈希表定位,再移到头部
moveToHead(node);
return node.value;
}
public void put(int key, int value) {
DLinkedNode node = cache.get(key);
if (node == null) {
// 如果 key 不存在,创建一个新的节点
DLinkedNode newNode = new DLinkedNode(key, value);
// 添加进哈希表
cache.put(key, newNode);
// 添加至双向链表的头部
addToHead(newNode);
++size;
if (size > capacity) {
// 如果超出容量,删除双向链表的尾部节点
DLinkedNode tail = removeTail();
// 删除哈希表中对应的项
cache.remove(tail.key);
--size;
}
}
else {
// 如果 key 存在,先通过哈希表定位,再修改 value,并移到头部
node.value = value;
moveToHead(node);
}
}
private void addToHead(DLinkedNode node) {
node.prev = head;
node.next = head.next;
head.next.prev = node;
head.next = node;
}
private void removeNode(DLinkedNode node) {
node.prev.next = node.next;
node.next.prev = node.prev;
}
private void moveToHead(DLinkedNode node) {
removeNode(node);
addToHead(node);
}
private DLinkedNode removeTail() {
DLinkedNode res = tail.prev;
removeNode(res);
return res;
}
}