简单LRU算法实现缓存

最简单的LRU算法实现，就是利用jdk的LinkedHashMap，覆写其中的removeEldestEntry(Map.Entry)方法即可，如下所示：

java 代码

1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.LinkedHashMap;
4. import java.util.concurrent.locks.Lock;
5. import java.util.concurrent.locks.ReentrantLock;
6. import java.util.Map;
7. /**
8. * 类说明：利用LinkedHashMap实现简单的缓存， 必须实现removeEldestEntry方法，具体参见JDK文档
9. *
10. * @author dennis
11. *
12. * @param <K>
13. * @param <V>
14. */
15. public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
16. private final int maxCapacity;
17. private static final float DEFAULT_LOAD_FACTOR = 0.75f;
18. private final Lock lock = new ReentrantLock();
19. public LRULinkedHashMap(int maxCapacity) {
20. super(maxCapacity, DEFAULT_LOAD_FACTOR, true);
21. this.maxCapacity = maxCapacity;
22. }
23. @Override
24. protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
25. return size() > maxCapacity;
26. }
27. @Override
28. public boolean containsKey(Object key) {
29. try {
30. lock.lock();
31. return super.containsKey(key);
32. } finally {
33. lock.unlock();
34. }
35. }
36. @Override
37. public V get(Object key) {
38. try {
39. lock.lock();
40. return super.get(key);
41. } finally {
42. lock.unlock();
43. }
44. }
45. @Override
46. public V put(K key, V value) {
47. try {
48. lock.lock();
49. return super.put(key, value);
50. } finally {
51. lock.unlock();
52. }
53. }
54. public int size() {
55. try {
56. lock.lock();
57. return super.size();
58. } finally {
59. lock.unlock();
60. }
61. }
62. public void clear() {
63. try {
64. lock.lock();
65. super.clear();
66. } finally {
67. lock.unlock();
68. }
69. }
70. public Collection<Map.Entry<K, V>> getAll() {
71. try {
72. lock.lock();
73. return new ArrayList<Map.Entry<K, V>>(super.entrySet());
74. } finally {
75. lock.unlock();
76. }
77. }
78. }

如果你去看LinkedHashMap的源码可知，LRU算法是通过双向链表来实现，当某个位置被命中，通过调整链表的指向将该位置调整到头位置，新加入 的内容直接放在链表头，如此一来，最近被命中的内容就向链表头移动，需要替换时，链表最后的位置就是最近最少使用的位置。
    LRU算法还可以通过计数来实现，缓存存储的位置附带一个计数器，当命中时将计数器加1，替换时就查找计数最小的位置并替换，结合访问时间戳来实现。这种 算法比较适合缓存数据量较小的场景，显然，遍历查找计数最小位置的时间复杂度为O(n)。我实现了一个，结合了访问时间戳，当最小计数大于 MINI_ACESS时，就移除最久没有被访问的项：

java 代码

1. import java.io.Serializable;
2. import java.util.ArrayList;
3. import java.util.Collection;
4. import java.util.HashMap;
5. import java.util.Iterator;
6. import java.util.Map;
7. import java.util.Set;
8. import java.util.concurrent.atomic.AtomicInteger;
9. import java.util.concurrent.atomic.AtomicLong;
10. import java.util.concurrent.locks.Lock;
11. import java.util.concurrent.locks.ReentrantLock;
12. /**
13. *
14. * @author dennis
15. * 类说明：当缓存数目不多时，才用缓存计数的传统LRU算法
16. * @param <K>
17. * @param <V>
18. */
19. public class LRUCache<K, V> implements Serializable {
20. private static final int DEFAULT_CAPACITY = 100;
21. protected Map<K, ValueEntry> map;
22. private final Lock lock = new ReentrantLock();
23. private final transient int maxCapacity;
24. private static int MINI_ACCESS = 10;
25. public LRUCache() {
26. this(DEFAULT_CAPACITY);
27. }
28. public LRUCache(int capacity) {
29. if (capacity <= 0)
30. throw new RuntimeException("缓存容量不得小于0");
31. this.maxCapacity = capacity;
32. this.map = new HashMap<K, ValueEntry>(maxCapacity);
33. }
34. public boolean ContainsKey(K key) {
35. try {
36. lock.lock();
37. return this.map.containsKey(key);
38. } finally {
39. lock.unlock();
40. }
41. }
42. public V put(K key, V value) {
43. try {
44. lock.lock();
45. if ((map.size() > maxCapacity - 1) && !map.containsKey(key)) {
46. // System.out.println("开始");
47. Set<Map.Entry<K, ValueEntry>> entries = this.map.entrySet();
48. removeRencentlyLeastAccess(entries);
49. }
50. ValueEntry valueEntry = map.put(key, new ValueEntry(value));
51. if (valueEntry != null)
52. return valueEntry.value;
53. else
54. return null;
55. } finally {
56. lock.unlock();
57. }
58. }
59. /**
60. * 移除最近最少访问
61. */
62. protected void removeRencentlyLeastAccess(
63. Set<Map.Entry<K, ValueEntry>> entries) {
64. // 最小使用次数
65. int least = 0;
66. // 最久没有被访问
67. long earliest = 0;
68. K toBeRemovedByCount = null;
69. K toBeRemovedByTime = null;
70. Iterator<Map.Entry<K, ValueEntry>> it = entries.iterator();
71. if (it.hasNext()) {
72. Map.Entry<K, ValueEntry> valueEntry = it.next();
73. least = valueEntry.getValue().count.get();
74. toBeRemovedByCount = valueEntry.getKey();
75. earliest = valueEntry.getValue().lastAccess.get();
76. toBeRemovedByTime = valueEntry.getKey();
77. }
78. while (it.hasNext()) {
79. Map.Entry<K, ValueEntry> valueEntry = it.next();
80. if (valueEntry.getValue().count.get() < least) {
81. least = valueEntry.getValue().count.get();
82. toBeRemovedByCount = valueEntry.getKey();
83. }
84. if (valueEntry.getValue().lastAccess.get() < earliest) {
85. earliest = valueEntry.getValue().count.get();
86. toBeRemovedByTime = valueEntry.getKey();
87. }
88. }
89. // System.out.println("remove:" + toBeRemoved);
90. // 如果最少使用次数大于MINI_ACCESS，那么移除访问时间最早的项(也就是最久没有被访问的项）
91. if (least > MINI_ACCESS) {
92. map.remove(toBeRemovedByTime);
93. } else {
94. map.remove(toBeRemovedByCount);
95. }
96. }
97. public V get(K key) {
98. try {
99. lock.lock();
100. V value = null;
101. ValueEntry valueEntry = map.get(key);
102. if (valueEntry != null) {
103. // 更新访问时间戳
104. valueEntry.updateLastAccess();
105. // 更新访问次数
106. valueEntry.count.incrementAndGet();
107. value = valueEntry.value;
108. }
109. return value;
110. } finally {
111. lock.unlock();
112. }
113. }
114. public void clear() {
115. try {
116. lock.lock();
117. map.clear();
118. } finally {
119. lock.unlock();
120. }
121. }
122. public int size() {
123. try {
124. lock.lock();
125. return map.size();
126. } finally {
127. lock.unlock();
128. }
129. }
130. public Collection<Map.Entry<K, V>> getAll() {
131. try {
132. lock.lock();
133. Set<K> keys = map.keySet();
134. Map<K, V> tmp = new HashMap<K, V>();
135. for (K key : keys) {
136. tmp.put(key, map.get(key).value);
137. }
138. return new ArrayList<Map.Entry<K, V>>(tmp.entrySet());
139. } finally {
140. lock.unlock();
141. }
142. }
143. class ValueEntry implements Serializable {
144. private V value;
145. private AtomicInteger count;
146. private AtomicLong lastAccess;
147. public ValueEntry(V value) {
148. this.value = value;
149. this.count = new AtomicInteger(0);
150. lastAccess = new AtomicLong(System.nanoTime());
151. }
152. public void updateLastAccess() {
153. this.lastAccess.set(System.nanoTime());
154. }
155. }
156. }