LRU算法及Java实现

LRU算法介绍
LRU是Least Recently Used的缩写，即最近最少使用，常用于页面置换算法，为虚拟页式存储管理服务。LRU算法的提出，是基于这样一个事实：在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这个，就是著名的局部性原理。此外，LRU算法也经常被用作缓存淘汰策略。本文将基于LRU算法的思想，使用Java语言实现一个我们自己的缓存工具类。

实现方式
最常见的实现是使用一个双向链表保存缓存数据，详细算法实现如下：

1. 新数据插入到链表头部；
2. 每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
3. 当链表满的时候，将链表尾部的数据丢弃。

优点：实现简单。
缺点：每次访问都需要更新链表，因此代价略高。

代码实现
本文将提供两个不同的实现版本，不过实现思想都是一模一样的。

版本一：

/**
* 在版本一中，我们自己利用HashMap和一个简单的双向链表来实现LRU缓存
*/
class LRUCache {

// 双向链表节点定义
class Node {
int key;
int val;
Node prev;
Node next;
}

private int capacity;
//保存链表的头节点和尾节点
private Node first;
private Node last;

private Map<Integer, Node> map;

public LRUCache(int capacity) {
this.capacity = capacity;
map = new HashMap<>(capacity);
}

public int get(int key) {
Node node = map.get(key);
//为空返回-1
if (node == null) {
return -1;
}
moveToHead(node);
return node.val;
}

private void moveToHead(Node node) {
if (node == first) {
return;
} else if (node == last) {
last.prev.next = null;
last = last.prev;
} else {
node.prev.next = node.next;
node.next.prev = node.prev;
}

node.prev = first.prev;
node.next = first;
first.prev = node;
first = node;
}

public void put(int key, int value) {
Node node = map.get(key);

if (node == null) {
node = new Node();
node.key = key;
node.val = value;

if(map.size() == capacity) {
removeLast();
}

addToHead(node);
map.put(key, node);
} else {
node.val = value;
moveToHead(node);
}
}

private void addToHead(Node node) {
if (map.isEmpty()) {
first = node;
last = node;
} else {
node.next = first;
first.prev = node;
first = node;
}
}

private void removeLast() {
map.remove(last.key);
Node prevNode = last.prev;
if (prevNode != null) {
prevNode.next = null;
last = prevNode;
}
}

@Override
public String toString() {
   return map.keySet().toString();
}

public static void main(String[] args) {
   LRUCache cache = new LRUCache(3);
cache.put(1, 1);
cache.put(2, 2);
cache.put(3, 3);
cache.get(1);
cache.put(4, 3);
System.out.println(cache);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
打印结果：
[4, 1, 3]
1
2
可以看到这种实现方式 get 和 put 的操作时间复杂度都是O(1)的。

版本二：

其实JDK已经为我们提供了一个基于HashMap和双向链表实现的数据结构，它就是LinkedHashMap，它内部维护的双向链表，可以帮助我们维护两种顺序：

插入顺序
LRU顺序
下面简单的介绍下LinkedHashMap

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
1
它继承自HashMap，同样具有快速查找特性。

/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;

/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;
1
2
3
4
5
6
7
8
9
内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。
另外根据注释，我们可以看出来，头节点head是最老的节点，而尾节点是最近一次被访问的节点，所以维护LRU顺序时，容量用完后，再执行新数据的插入的话，会移除头节点。

final boolean accessOrder;
1
accessOrder决定了维护的是哪一种顺序，默认为 false，此时维护的是插入顺序。为true时，维护的就是LRU顺序了。

void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
1
2
LinkedHashMap 最重要的是上述这两个用于维护顺序的函数，它们会在 put、get 等方法中调用。

void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最少使用的节点。

void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
1
2
3
4
5
6
7
在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最老的节点，也就是链表首部节点 first。

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
1
2
3
removeEldestEntry() 默认返回 false，如果需要让它为 true，需要继承 LinkedHashMap 并且重写这个方法，这是实现 LRU 缓存的关键，通过移除最近最少使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。

接下来我们基于JDK提供给我们的LinkedHashMap来实现LRU缓存

public class LRUCache<K,V> extends LinkedHashMap<K, V>{

   //首先设定最大缓存空间 MAX_ENTRIES 为 3；
   private static final int MAX_ENTRIES = 3;

   //之后使用LinkedHashMap的构造函数将 accessOrder设置为 true，开启 LRU顺序；
   public LRUCache() {
       super(MAX_ENTRIES, 0.75f, true);
   }

   //最后覆盖removeEldestEntry(）方法实现，在节点多于 MAX_ENTRIES 就会将最近最少使用的数据移除。
   //因为这个函数默认返回false，不重写的话缓存爆了的时候无法删除最近最久未使用的节点
   @Override
   protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
       //在容量超过最大允许节点数的时候返回true，使得在afterNodeInsertion函数中能执行removeNode()
       return size() > MAX_ENTRIES;
   }

   public static void main(String[] args) {
   LRUCache<Integer, Integer> cache = new LRUCache<>();
   cache.put(1, 1);
   cache.put(2, 2);
   cache.put(3, 3);
   cache.get(1);
   cache.put(4, 4);
   System.out.println(cache.keySet());
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
打印结果

[3, 1, 4]
1
版本二参考内容：CyC2018 CS-Notes
————————————————
版权声明：本文为CSDN博主「许大侠0610」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u013568373/article/details/90607083

LRU算法及Java实现相关推荐

LRU算法的Java实现
一.LRU算法介绍 LRU算法全称Least Recently Used,也就是检查最近最少使用的数据的算法.这个算法通常使用在内存淘汰策略中,用于将不常用的数据转移出内存,将空间腾给最近更常用的&q ...
未使用的分配java,最近最久未使用页面淘汰算法———LRU算法（java实现）
LRU算法,即Last Recently Used ---选择最后一次访问时间距离当前时间最长的一页并淘汰之--即淘汰最长时间没有使用的页按照最多5块的内存分配情况,实现LRU算法代码如下: pub ...
LRU算法（JAVA实现）
一.算法介绍最近最久未使用(Least Recently Used LRU)算法是⼀种缓存淘汰策略,它是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法.该算法的思路是,发生缺页中 ...
缓存淘汰算法--LRU算法
缓存淘汰算法--LRU算法参考: https://www.cnblogs.com/dailidong/p/7571178.html https://blog.csdn.net/wangxilong1 ...
java 最少使用(lru)置换算法_「面试」LRU了解么？看看LinkedHashMap如何实现LRU算法...
以下内容均是本人原创,希望你看完之后能有更多更深入的了解,欢迎关注➕ 问题:使用Java完成一个简单的LRU算法什么是LRU算法 LRU(Least Recently Used),也就是最近最少使用 ...
使用java.util.LinkedList模拟实现内存页面置换算法--LRU算法
一,LRU算法介绍 LRU是内存分配中"离散分配方式"之分页存储管理方式中用到的一个算法.每个进程都有自己的页表,进程只将自己的一部分页面加载到内存的物理块中,当进程在运行过程中, ...
java 最少使用(lru)置换算法_缓存置换算法 - LRU算法
LRU算法 1 原理对于在内存中并且不被使用的数据块就是LRU,这类数据需要从内存中删除,以腾出空间来存储常用的数据. LRU算法(Least Recently Used,最近最少使用),是内存管理 ...
缓存淘汰策略—LRU算法(java代码实现)
LRU 原理 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是"如果数据最近被访问过,那么将来被访问的几率也更高" ...
LRU算法java实现
LRU全称是Least Recently Used,即最近最久未使用的意思. LRU算法的设计原则是:如果一个数据在最近一段时间没有被访问到,那么在将来它被访问的可能性也很小.也就是说,当限定的空间已 ...

LRU算法及Java实现

LRU算法及Java实现相关推荐

最新文章

热门文章