一、什么是緩存
這里說的緩存是一種廣義的概念，在計算機存儲層次結構中，低一層的存儲器都可以看做是高一層的緩存。比如Cache是內存的緩存，內存是硬盤的緩存，硬盤是網絡的緩存等等。
緩存可以有效地解決存儲器性能與容量的這對矛盾，但絕非看上去那么簡單。如果緩存算法設計不當，非但不能提高訪問速度，反而會使系統變得更慢。
從本質上來說，緩存之所以有效是因為程序和數據的局部性（locality）。程序會按固定的順序執行，數據會存放在連續的內存空間并反復讀寫。這些特點使得我們可以緩存那些經常用到的數據，從而提高讀寫速度。
緩存的大小是固定的，它應該只保存最常被訪問的那些數據。然而未來不可預知，我們只能從過去的訪問序列做預測，于是就有了各種各樣的緩存替換策略。本文介紹一種簡單的緩存策略，稱為最近最少使用（LRU，Least Recently Used）算法。
二、LRU的實現
我們以內存訪問為例解釋緩存的工作原理。假設緩存的大小固定，初始狀態為空。每發生一次讀內存操作，首先查找待讀取的數據是否存在于緩存中，若是，則緩存命中，返回數據；若否，則緩存未命中，從內存中讀取數據，并把該數據添加到緩存中。向緩存添加數據時，如果緩存已滿，則需要刪除訪問時間最早的那條數據，這種更新緩存的方法就叫做LRU。
實現LRU時，我們需要關注它的讀性能和寫性能，理想的LRU應該可以在O(1)的時間內讀取一條數據或更新一條數據，也就是說讀寫的時間復雜度都是O(1)。
此時很容易想到使用HashMap，根據數據的鍵訪問數據可以達到O(1)的速度。但是更新緩存的速度卻無法達到O(1)，因為需要確定哪一條數據的訪問時間最早，這需要遍歷所有緩存才能找到。
因此，我們需要一種既按訪問時間排序，又能在常數時間內隨機訪問的數據結構。
這可以通過HashMap+雙向鏈表實現。HashMap保證通過key訪問數據的時間為O(1)，雙向鏈表則按照訪問時間的順序依次穿過每個數據。之所以選擇雙向鏈表而不是單鏈表，是為了可以從中間任意結點修改鏈表結構，而不必從頭結點開始遍歷。
如下圖所示，黑色部分為HashMap的結構，紅色箭頭則是雙向鏈表的正向連接（逆向連接未畫出）?？梢郧逦乜吹?，數據的訪問順序是1->3->5->6->10。我們只需要在每次訪問過后改變鏈表的連接順序即可。
實現代碼如下：
/**
* @author wjg
*
* LRU（Least Recently Used）緩存算法
* 使用HashMap+雙向鏈表，使get和put的時間復雜度達到O(1)。
* 讀緩存時從HashMap中查找key，更新緩存時同時更新HashMap和雙向鏈表，雙向鏈表始終按照訪問順序排列。
*
*/
public class LRUCache {
/**
* @param args
* 測試程序，訪問順序為[[1,1],[2,2],[1],[3,3],[2],[4,4],[1],[3],[4]]，其中成對的數調用put，單個數調用get。
* get的結果為[1],[-1],[-1],[3],[4]，-1表示緩存未命中，其它數字表示命中。
*/
public static void main(String[] args) {
LRUCache cache = new LRUCache(2);
cache.put(1, 1);
cache.put(2, 2);
System.out.println(cache.get(1));
cache.put(3, 3);
System.out.println(cache.get(2));
cache.put(4, 4);
System.out.println(cache.get(1));
System.out.println(cache.get(3));
System.out.println(cache.get(4));
}
// 緩存容量
private final int capacity;
// 用于加速緩存項隨機訪問性能的HashMap
private HashMap<Integer, Entry> map;
// 雙向鏈表頭結點，該側的緩存項訪問時間較早
private Entry head;
// 雙向鏈表尾結點，該側的緩存項訪問時間較新
private Entry tail;
public LRUCache(int capacity) {
this.capacity = capacity;
map = new HashMap<Integer, Entry>((int)(capacity / 0.75 + 1), 0.75f);
head = new Entry(0, 0);
tail = new Entry(0, 0);
head.next = tail;
tail.prev = head;
}
/**
* 從緩存中獲取key對應的值，若未命中則返回-1
* @param key 鍵
* @return key對應的值，若未命中則返回-1
*/
public int get(int key) {
if (map.containsKey(key)) {
Entry entry = map.get(key);
popToTail(entry);
return entry.value;
}
return -1;
}
/**
* 向緩存中插入或更新值
* @param key 待更新的鍵
* @param value 待更新的值
*/
public void put(int key, int value) {
if (map.containsKey(key)) {
Entry entry = map.get(key);
entry.value = value;
popToTail(entry);
}
else {
Entry newEntry = new Entry(key, value);
if (map.size() >= capacity) {
Entry first = removeFirst();
map.remove(first.key);
}
addToTail(newEntry);
map.put(key, newEntry);
}
}
/**
* 緩存項的包裝類，包含鍵、值、前驅結點、后繼結點
* @author wjg
*
*/
class Entry {
int key;
int value;
Entry prev;
Entry next;
Entry(int key, int value) {
this.key = key;
this.value = value;
}
}
// 將entry結點移動到鏈表末端
private void popToTail(Entry entry) {
Entry prev = entry.prev;
Entry next = entry.next;
prev.next = next;
next.prev = prev;
Entry last = tail.prev;
last.next = entry;
tail.prev = entry;
entry.prev = last;
entry.next = tail;
}
// 移除鏈表首端的結點
private Entry removeFirst() {
Entry first = head.next;
Entry second = first.next;
head.next = second;
second.prev = head;
return first;
}
// 添加entry結點到鏈表末端
private void addToTail(Entry entry) {
Entry last = tail.prev;
last.next = entry;
tail.prev = entry;
entry.prev = last;
entry.next = tail;
}
}
每個方法和成員變量前都有中文注釋，不必過多解釋。
值得一提的是，Java API中其實已經有數據類型提供了我們需要的功能，就是LinkedHashMap這個類。該類內部也是采用HashMap+雙向鏈表實現的。使用這個類實現LRU就簡練多了。
/**
*
* 一個更簡單實用的LRUCache方案，使用LinkedHashMap即可實現。
* LinkedHashMap提供了按照訪問順序排序的方案，內部也是使用HashMap+雙向鏈表。
* 只需要重寫removeEldestEntry方法，當該方法返回true時，LinkedHashMap會刪除最舊的結點。
*
* @author wjg
*
*/
public class LRUCacheSimple {
/**
* @param args
*/
public static void main(String[] args) {
LRUCacheSimple cache = new LRUCacheSimple(2);
cache.put(1, 1);
cache.put(2, 2);
System.out.println(cache.get(1));
cache.put(3, 3);
System.out.println(cache.get(2));
cache.put(4, 4);
System.out.println(cache.get(1));
System.out.println(cache.get(3));
System.out.println(cache.get(4));
}
private LinkedHashMap<Integer, Integer> map;
private final int capacity;
public LRUCacheSimple(int capacity) {
this.capacity = capacity;
map = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true){
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > capacity;
}
};
}
public int get(int key) {
return map.getOrDefault(key, -1);
}
public void put(int key, int value) {
map.put(key, value);
}
}
只需要覆寫LinkedHashMap的removeEldestEntry方法，在緩存已滿的情況下返回true，內部就會自動刪除最老的元素。
感興趣的同學可以做一下LeetCode 146. LRU Cache這道題，嘗試一下如何實現這個算法。
完整版代碼LRUCache.java收錄在GitHub倉庫Algorithms中，歡迎大家下載試用。
參考資料
Cache replacement policies WikiPedia
146. LRU Cache LeetCode
Laziest implementation: Java's LinkedHashMap takes care of everything sky-xu
