大家好，我是大明哥，一個專注於【死磕 Java】系列創作的男人
個人網站：https://www.cmsblogs.com/。專注於 Java 優質系列文章分享，提供一站式 Java 學習資料
LRU，即 Least Recently Use ，直譯為 “最近最少使用”。它是根據資料的歷史訪問記錄來進行資料淘汰的，淘汰掉最先訪問的資料，其核心思想是 如果資料最近被訪問過，那麼將來被訪問的機率也會更加高。
要實現 LRU，需要做到兩點：
- 查詢出最近最晚使用的項
- 給最近使用的項做一個標記
實現的方案有多種，這裡小編主要介紹兩種：
- LinkedHashMap
- 雙向連結串列 + HashMap
LinkedHashMap 實現
利用 LinkedHashMap 的原因就在於 LinkedHashMap 是有序的，預設情況下是按照元素的新增順序儲存的，也可以調整為根據訪問順序來調整內部順序（設定引數 accessOrder 進行調整），即最近讀取的資料放在最前面，我們就是利用 LinkedHashMap 的這個特性來實現 LRU。先來一個簡單的例子吧：
public static void main(String[] args){
Map<String,String> map = new LinkedHashMap(10,0.75f,true);
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
System.out.println("原始順序為：");
for(Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();it.hasNext();){
System.out.print(it.next().getKey() + " ");
}
System.out.println();
map.get("2");
System.out.println("訪問 4 之後的順序為：");
for(Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();it.hasNext();){
System.out.print(it.next().getKey() + " ");
}
}
執行結果：
原始順序為：
1 2 3 4
訪問 4 之後的順序為：
1 3 4 2
更多關於 LinkedHashMap，請看這篇文章：圖解集合6：LinkedHashMap
LinkedHashMap 實現 LRU 有兩種方式，一種是繼承 LinkedHashMap，一種是利用組合的方式，下面分別演示這兩種情況。
繼承 LinkedHashMap
採用繼承的方式實現起來是非常簡單的，因為 LinkedHashMap 本身就已經具備了 LRU 的特性，我們只需要實現一點：當容器中元素個數超過我們設定的容量後，刪除第一個元素即可。同時由於 LinkedHashMap 本身不具備執行緒安全，我們需要確保他執行緒安全，這個也很簡單，重寫 LinkedHashMap 的 get() 和 put() 方法即可，或者使用 Collections.synchronizedMap() 方法也可以。實現如下：
public class LRUCacheLinkedHashMap<K,V> extends LinkedHashMap<K,V> {
/**
* 定一快取容量
*/
private int capacity;
LRUCacheLinkedHashMap(int capacity){
// AccessOrder = true
super(capacity,0.75f,true);
this.capacity = capacity;
}
/**
* 實現LRU的關鍵方法，如果 map 裡面的元素個數大於了快取最大容量，則刪除連結串列的頂端元素
*
* @param eldest
* @return
*/
@Override
public boolean removeEldestEntry(Map.Entry<K, V> eldest){
System.out.println(eldest.getKey() + "=" + eldest.getValue());
return size()>capacity;
}
@Override
public synchronized V get(Object key) {
return super.get(key);
}
@Override
public synchronized V put(K key, V value) {
return super.put(key, value);
}
}
驗證
public static void main(String[] args){
LRUCacheLinkedHashMap cache = new LRUCacheLinkedHashMap(5);
cache.put("1","a");
cache.put("2","b");
cache.put("3","c");
cache.put("4","d");
cache.put("5","e");
System.out.println("插入 5 個元素後的順序");
printlnCache(cache);
// 插入第 6 個元素
cache.put("6","e");
System.out.println("插入第 6 個元素後的順序");
printlnCache(cache);
// 訪問 第 3 個元素
cache.get("3");
System.out.println("訪問元素 3 後的順序");
printlnCache(cache);
}
private static void printlnCache(LRUCacheLinkedHashMap cacheMap){
for(Iterator<Map.Entry<String,String>> it = cacheMap.entrySet().iterator(); it.hasNext();){
System.out.print(it.next().getKey() + " ");
}
System.out.println();
}
執行結果：
插入 5 個元素後的順序
1 2 3 4 5
插入第 6 個元素後的順序
2 3 4 5 6
訪問元素 3 後的順序
2 4 5 6 3
執行結果完全符合我們的預期
組合 LinkedHashMap
使用組合的方式可能會更加優雅些，但是由於沒有實現 Map 介面，所以就不能使用 Collections.synchronizedMap() 方式來保證執行緒安全性了，所以需要在每個方法處增加 synchronized 來確保執行緒安全。實現方式如下：
public class LRUCache<K,V> {
private int capacity;
private Map<K,V> cacheMap;
public LRUCache(int capacity){
this.capacity = capacity;
cacheMap = new LinkedHashMap<>(capacity,0.75f,true);
}
public synchronized void put(K k,V v){
cacheMap.put(k,v);
// 移除第一個元素
if(cacheMap.size() > capacity){
K first = this.keyIterator().next();
cacheMap.remove(first);
}
}
public synchronized V get(K k){
return cacheMap.get(k);
}
public Iterator<K> keyIterator(){
return cacheMap.keySet().iterator();
}
}
驗證：
public static void main(String[] args) {
LRUCache lruCache = new LRUCache(5);
lruCache.put("1","a");
lruCache.put("2","b");
lruCache.put("3","c");
lruCache.put("4","d");
lruCache.put("5","e");
System.out.println("插入 5 個元素後的順序");
println(lruCache);
// 插入第 6 個元素
lruCache.put("6","e");
System.out.println("插入 第 6 個元素後的順序");
println(lruCache);
// 訪問 第 3 個元素
lruCache.get("3");
System.out.println("訪問元素 3 後的順序");
println(lruCache);
}
private static void println(LRUCache lruCache){
for(Iterator it = lruCache.keyIterator(); it.hasNext();){
System.out.print(it.next() + " ");
}
System.out.println();
}
執行結果如下：
插入 5 個元素後的順序
1 2 3 4 5
插入 第 6 個元素後的順序
2 3 4 5 6
訪問元素 3 後的順序
2 4 5 6 3
組合的方式也顯得非常簡單，有兩點需要注意：
- 保證每個方法的執行緒安全
- put 時，需要檢視當前容量是否超過設定的容量，超過則需要刪除第一個元素。當然小編這種是實現方式不是很優雅，這麼做知識為了能夠更加好闡述 LRU 的實現。更好的方案是在構造 LinkedHashMap 時，重寫
removeEldestEntry()，如下：
cacheMap = new LinkedHashMap<K,V>(capacity,0.75f,true){
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size()>capacity;
}
};
連結串列 + HashMap 實現
我們想想，在不利用現存資料結構的條件（如 LinkedHashMap）如何實現一個 LRU 呢？快取部分容易實現，我們都知道利用 HashMap 即可，但是如何實現快取容量不足時丟棄最不常用的資料的功能？
- 利用時間戳。每一個訪問，增加的元素我們都給其更新一個時間戳，在 put 的時候，檢查，刪除時間戳最小的就可以了。這種方法可以實現，但是代價較高，就是我們需要遍歷整個資料，得到最小的時間戳。
- 我們可以換位思考，我們其實不需要關注每個節點的增加或者遍歷時間，我們只需要知道那個節點是最先訪問就可以了，所以我們可以利用連結串列記錄訪問記錄，有新資料加入時放在連結串列的 head 節點，每次訪問也將該資料放在 head 節點，那麼連結串列的 tail 一定是最早訪問的節點，所以每次當容量不足的時候刪除 tail 節點資料並將它的前驅節點設定為 tail 就可以了。注意，這個連結串列是一個雙向連結串列。程式碼如下：
public class LinkedLRUCache<K,V> {
private int capacity;
private Map<K,LRUNode> map;
private LRUNode head;
private LRUNode tail;
LinkedLRUCache(int capacity){
this.capacity = capacity;
this.map = new HashMap<>();
}
public synchronized void put(K k,V v){
LRUNode node = map.get(k);
// 存在該 key，將節點的設定為 head
if(node != null){
node.value = v;
remove(node,false);
}else{
/**
* 該節點不存在
* 1、將該節點加入快取
* 2、設定該節點為 head
* 3、判斷是否超出容量
*/
node = new LRUNode(k,v);
if(map.size() >= capacity){
//刪除 tail 節點
remove(tail,true);
}
map.put(k,node);
setHead(node);
}
// 設定當前節點為首節點
setHead(node);
}
public Object get(String key) {
LRUNode node = map.get(key);
if (node != null) {
// 將剛操作的元素放到head
remove(node, false);
setHead(node);
return node.value;
}
return null;
}
/**
* 設定頭結點
*
* @param node
*/
private void setHead(LRUNode node) {
if(head != null){
node.next = head;
head.prev = node;
}
head = node;
if(tail == null){
tail = node;
}
}
/**
* 從連結串列中刪除此Node
*
* @param node
* @param flag 為 true 就刪除該節點的 key
*/
private void remove(LRUNode node,boolean flag) {
if (node.prev != null) {
node.prev.next = node.next;
} else {
head = node.next;
}
if (node.next != null) {
node.next.prev = node.prev;
} else {
tail = node.prev;
}
node.next = null;
node.prev = null;
if (flag) {
map.remove(node.key);
}
}
private Iterator iterator(){
return map.keySet().iterator();
}
private class LRUNode<K,V> {
/**
* cache 的 key
*/
private K key;
/**
* cache 的 value
*/
private V value;
private LRUNode next;
private LRUNode prev;
LRUNode(K key, V value) {
this.key = key;
this.value = value;
}
}
}
驗證
public static void main(String[] args){
LRUCache lruCache = new LRUCache(5);
lruCache.put("1","a");
lruCache.put("2","b");
lruCache.put("3","c");
lruCache.put("4","d");
lruCache.put("5","e");
System.out.println("插入 5 個元素");
println(lruCache);
System.out.println("插入 3 元素");
lruCache.put("3","c");
println(lruCache);
System.out.println("插入第 6 個元素");
lruCache.put("6","f");
println(lruCache);
System.out.println("訪問 4 元素");
lruCache.get("4");
println(lruCache);
}
private static void println(LRUCache lruCache){
Iterator iterator = lruCache.keyIterator();
while (iterator.hasNext()){
System.out.print(iterator.next() + " ");
}
System.out.println();
}
執行結果：
插入 5 個元素
1 2 3 4 5
插入 3 元素
1 2 4 5 3
插入第 6 個元素
2 4 5 3 6
訪問 4 元素
2 5 3 6 4