本文详细介绍LRU（最近最少使用）缓存算法的工作原理及其两种实现方式：自定义双向链表和利用Java自带双向链表。通过实例演示了如何在不同场景下高效地运用LRU算法。
LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。
- 最常见的实现是使用一个链表保存缓存数据，详细算法实现如下
- 新数据插入到链表头部；
- 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
- 当链表满的时候，将链表尾部的数据丢弃。
【命中率】
当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较严重。
【复杂度】
实现简单。
【代价】
命中时需要遍历链表，找到命中的数据块索引，然后需要将数据移到头部。
在一般标准的操作系统教材里，会用下面的方式来演示 LRU 原理，假设内存只能容纳3个页大小，按照 7 0 1 2 0 3 0 4 的次序访问页。假设内存按照栈的方式来描述访问时间，在上面的，是最近访问的，在下面的是，最远时间访问的，LRU就是这样工作的。
但是如果让我们自己设计一个基于 LRU 的缓存，这样设计可能问题很多，这段内存按照访问时间进行了排序，会有大量的内存拷贝操作，所以性能肯定是不能接受的。
那么如何设计一个LRU缓存，使得放入和移除都是 O(1) 的，我们需要把访问次序维护起来，但是不能通过内存中的真实排序来反应，有一种方案就是使用双向链表。
【如果是单链表的话（单链表只知道head指针），移除尾部节点时，时间复杂度不再是O(1)，而是O(n)】
基于 HashMap 和 双向链表实现 LRU 的
整体的设计思路是，可以使用 HashMap 存储 key，这样可以做到 save 和 get key的时间都是 O(1)，而 HashMap 的 Value 指向双向链表实现的 LRU 的 Node 节点，如图所示。
LRU 存储是基于双向链表实现的，下面的图演示了它的原理。其中 h 代表双向链表的表头，t 代表尾部。首先预先设置 LRU 的容量，如果存储满了，可以通过 O(1) 的时间淘汰掉双向链表的尾部，每次新增和访问数据，都可以通过 O(1)的效率把新的节点增加到对头，或者把已经存在的节点移动到队头。
下面展示了，预设大小是 3 的，LRU存储的在存储和访问过程中的变化。为了简化图复杂度，图中没有展示 HashMap部分的变化，仅仅演示了上图 LRU 双向链表的变化。我们对这个LRU缓存的操作序列如下：
save("key1", 7)， save("key2", 0)， save("key3", 1)， save("key4", 2)， get("key2")， save("key5", 3)， get("key2")， save("key6", 4)
相应的 LRU 双向链表部分变化如下：
核心操作的步骤:
【1】save(key, value)，首先在 HashMap 找到 Key 对应的节点，如果节点存在，更新节点的值，并把这个节点移动队头。如果不存在，需要构造新的节点，并且尝试把节点塞到队头，如果LRU空间不足，则通过 tail 淘汰掉队尾的节点，同时在 HashMap 中移除 Key。
【2】get(key)，通过 HashMap 找到 LRU 链表节点，把节点插入到队头，返回缓存的值。
完整基于 Java 的代码参考如下：
方法1自定义双链表：
class DLinkedNode {
String key;
int value;
DLinkedNode pre;
DLinkedNode post;
}
public class LRUCache {
private Hashtable<String, DLinkedNode>
cache = new Hashtable<String, DLinkedNode>();
private int count;
private int capacity;
private DLinkedNode head, tail;
public LRUCache(int capacity) {
this.count = 0;
this.capacity = capacity;
head = new DLinkedNode();
head.pre = null;
tail = new DLinkedNode();
tail.post = null;
head.post = tail;
tail.pre = head;
}
public int get(String key) {
DLinkedNode node = cache.get(key);
if(node == null){
return -1; // should raise exception here.
}
// move the accessed node to the head;
this.moveToHead(node);
return node.value;
}
public void set(String key, int value) {
DLinkedNode node = cache.get(key);
if(node == null){
DLinkedNode newNode = new DLinkedNode();
newNode.key = key;
newNode.value = value;
this.cache.put(key, newNode);
this.addNode(newNode);
++count;
if(count > capacity){
// pop the tail
DLinkedNode tail = this.popTail();
this.cache.remove(tail.key);
--count;
}
}else{
// update the value.
node.value = value;
this.moveToHead(node);
}
}
/**
* Always add the new node right after head;
*/
private void addNode(DLinkedNode node){
node.pre = head;
node.post = head.post;
head.post.pre = node;
head.post = node;
}
/**
* Remove an existing node from the linked list.
*/
private void removeNode(DLinkedNode node){
DLinkedNode pre = node.pre;
DLinkedNode post = node.post;
pre.post = post;
post.pre = pre;
}
/**
* Move certain node in between to the head.
*/
private void moveToHead(DLinkedNode node){
this.removeNode(node);
this.addNode(node);
}
// pop the current tail.
private DLinkedNode popTail(){
DLinkedNode res = tail.pre;
this.removeNode(res);
return res;
}
}方法2使用Java自带的双链表：
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
/**
* @description: lru算法，线程安全
* 使用jdk的双向链表
* get元素时，如果不存在则返回null，反之，删除链表的该节点，把该节点放到表头
* put元素时，
* 如果没满，
* 如果map中不存在，则插入表头，同时存入map
* 如果map中存在，删除链表的该节点，把该节点放到表头；同时更新map中的值
* 如果已满，
* 如果map中不存在，则先删除表尾节点，再把新节点插入表头，同时存入map
* 如果map中存在，则先删除表尾节点，再把新节点插入表头，同时更新map中的值
*/
class Node<K,V>{
/**
* 键
*/
K key;
/**
* 值
*/
V value;
public Node(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public String toString() {
return "(" +
"key=" + key +
", value=" + value +
')';
}
}
class LruCache<K,V> {
/**
* 通过与链表配合，使其查找速度在O(1)下完成
*/
private Map<K,Node<K,V>> map;
/**
* 链表优点：便于添加和删除元素，都在O(1)时间内完成
*/
private LinkedList<Node<K,V>> linkedList;
/**
* 缓存存储元素的数量
*/
private int size;
private int defaultSize = 16;
public LruCache() {
this(16);
}
public LruCache(int size) {
if(size <= 0){
this.size = 16;
}else {
this.size = size;
}
this.map = new HashMap<>(this.size);
this.linkedList = new LinkedList<>();
}
/**
* 判断缓存元素是否存在，如果存在，则把链表中的元素删除，map中的数据不用删除，再在链表头部插入元素，并更新map
* 当缓存没有满的话，直接把元素插入链表的表头，否则移除表尾元素（最旧未访问元素）,在插入表头，注意更新map
*
* @param key : 键
* @param value ：值
*/
public synchronized void put(K key,V value){
//待添加元素
Node<K,V> insertNode = new Node<>(key, value);
//判断元素是否存在
Node<K,V> node = map.get(key);
//如果存在，则把链表中的元素删除，map中的数据不用删除，再在链表头部插入元素
if(Objects.nonNull(node)){
linkedList.remove(node);
linkedList.addFirst(insertNode);
//更新map中的相应value
map.put(key,insertNode);
return;
}
//如果缓存已经满的话，则删除最后未访问元素
if(this.size == map.size()){
//直接删除队列尾部元素，同时更新map
linkedList.removeLast();
map.remove(key);
//在队列头部插入元素，同时更新map
linkedList.addFirst(insertNode);
map.put(key,insertNode);
return;
}
//如果缓存没满，则执行添加即可
map.put(key,insertNode);
linkedList.addFirst(insertNode);
}
/**
* 如果key存在，则返回相应value值，否者返回null
*
* @param key ：键
* @return ：值
*/
public synchronized V get(K key){
//先向map查询是否存在
Node<K,V> node = map.get(key);
if(Objects.isNull(node)){
return null;
}
//如果存在，则先删除后添加到队列头
linkedList.remove(node);
linkedList.addFirst(node);
return node.value;
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
for(Node<K,V> node : linkedList ){
stringBuilder.append(node.toString()).append(",");
}
return stringBuilder.toString().substring(0,stringBuilder.length()-1);
}
}
public class LruCacheTest {
public static void main(String[] args){
LruCache<String,String> lruCache = new LruCache<>(3);
lruCache.put("one","one");
lruCache.put("two","two");
lruCache.put("three","three");
System.out.println(lruCache.toString());
lruCache.get("one");
System.out.println(lruCache.toString());
lruCache.put("four","four");
System.out.println(lruCache.toString());
lruCache.get("one");
System.out.println(lruCache.toString());
System.out.println(lruCache.get("five"));
lruCache.put("four","five");
System.out.println(lruCache.toString());
}
}
扫一扫
575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
