基本概念

LRU全稱是Least Recently Used，即最近最少使用的意思。
LRU算法的設計原則是：如果一個數據在最近一段時間沒有被訪問到，那么在將來它被訪問的可能性也很小。也就是說，當限定的空間已存滿數據時，應當把最久沒有被訪問到的數據淘汰。

實現LRU

1.用一個數組來存儲數據，給每一個數據項標記一個訪問時間戳，每次插入新數據項的時候，先把數組中存在的數據項的時間戳自增，并將新數據項的時間戳置為0并插入到數組中。每次訪問數組中的數據項的時候，將被訪問的數據項的時間戳置為0。當數組空間已滿時，將時間戳最大的數據項淘汰。

2.利用一個鏈表來實現，每次新插入數據的時候將新數據插到鏈表的頭部；每次緩存命中（即數據被訪問），則將數據移到鏈表頭部；那么當鏈表滿的時候，就將鏈表尾部的數據丟棄。

lru.png

1. 新數據插入到鏈表頭部；
2. 每當緩存命中（即緩存數據被訪問），則將數據移到鏈表頭部；
3. 當鏈表滿的時候，將鏈表尾部的數據丟棄。

3.利用鏈表和hashmap。當需要插入新的數據項的時候，如果新數據項在鏈表中存在（一般稱為命中），則把該節點移到鏈表頭部，如果不存在，則新建一個節點，放到鏈表頭部，若緩存滿了，則把鏈表最后一個節點刪除即可。在訪問數據的時候，如果數據項在鏈表中存在，則把該節點移到鏈表頭部，否則返回-1。這樣一來在鏈表尾部的節點就是最近最久未訪問的數據項。

對于第一種方法，需要不停地維護數據項的訪問時間戳，另外，在插入數據、刪除數據以及訪問數據時，時間復雜度都是O(n)。對于第二種方法，鏈表在定位數據的時候時間復雜度為O(n)。所以在一般使用第三種方式來是實現LRU算法。

LinkedHashMap底層就是用的HashMap加雙鏈表實現的，而且本身已經實現了按照訪問順序的存儲。此外，LinkedHashMap中本身就實現了一個方法removeEldestEntry用于判斷是否需要移除最不常讀取的數，方法默認是直接返回false，不會移除元素，所以需要重寫該方法。即當緩存滿后就移除最不常用的數。

實現代碼

public class LRU<K,V> {

  private static final float hashLoadFactory = 0.75f;
  private LinkedHashMap<K,V> map;
  private int cacheSize;

  public LRU(int cacheSize) {
    this.cacheSize = cacheSize;
    int capacity = (int)Math.ceil(cacheSize / hashLoadFactory) + 1;
    map = new LinkedHashMap<K,V>(capacity, hashLoadFactory, true){
      private static final long serialVersionUID = 1;

      @Override
      protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > LRU.this.cacheSize;
      }
    };
  }

  public synchronized V get(K key) {
    return map.get(key);
  }

  public synchronized void put(K key, V value) {
    map.put(key, value);
  }

  public synchronized void clear() {
    map.clear();
  }

  public synchronized int usedSize() {
    return map.size();
  }

  public void print() {
    for (Map.Entry<K, V> entry : map.entrySet()) {
      System.out.print(entry.getValue() + "--");
    }
    System.out.println();
  }
}

當存在熱點數據時，LRU的效率很好，但偶發性的、周期性的批量操作會導致LRU命中率急劇下降，緩存污染情況比較嚴重。

2. LRU-K

2.1. 原理

LRU-K中的K代表最近使用的次數，因此LRU可以認為是LRU-1。LRU-K的主要目的是為了解決LRU算法“緩存污染”的問題，其核心思想是將“最近使用過1次”的判斷標準擴展為“最近使用過K次”。

2.2. 實現

相比LRU，LRU-K需要多維護一個隊列，用于記錄所有緩存數據被訪問的歷史。只有當數據的訪問次數達到K次的時候，才將數據放入緩存。當需要淘汰數據時，LRU-K會淘汰第K次訪問時間距當前時間最大的數據。詳細實現如下：

LRU_K.png

1. 數據第一次被訪問，加入到訪問歷史列表；

2. 如果數據在訪問歷史列表里后沒有達到K次訪問，則按照一定規則（FIFO，LRU）淘汰；

3. 當訪問歷史隊列中的數據訪問次數達到K次后，將數據索引從歷史隊列刪除，將數據移到緩存隊列中，并緩存此數據，緩存隊列重新按照時間排序；

4. 緩存數據隊列中被再次訪問后，重新排序；

5. 需要淘汰數據時，淘汰緩存隊列中排在末尾的數據，即：淘汰“倒數第K次訪問離現在最久”的數據。

LRU-K具有LRU的優點，同時能夠避免LRU的缺點，實際應用中LRU-2是綜合各種因素后最優的選擇，LRU-3或者更大的K值命中率會高，但適應性差，需要大量的數據訪問才能將歷史訪問記錄清除掉。

2.3. 分析

【命中率】

LRU-K降低了“緩存污染”帶來的問題，命中率比LRU要高。

【復雜度】

LRU-K隊列是一個優先級隊列，算法復雜度和代價比較高。

【代價】

由于LRU-K還需要記錄那些被訪問過、但還沒有放入緩存的對象，因此內存消耗會比LRU要多；當數據量很大的時候，內存消耗會比較可觀。

LRU-K需要基于時間進行排序（可以需要淘汰時再排序，也可以即時排序），CPU消耗比LRU要高。

3. Two queues（2Q）

3.1. 原理

Two queues（以下使用2Q代替）算法類似于LRU-2，不同點在于2Q將LRU-2算法中的訪問歷史隊列（注意這不是緩存數據的）改為一個FIFO緩存隊列，即：2Q算法有兩個緩存隊列，一個是FIFO隊列，一個是LRU隊列。

3.2. 實現

當數據第一次訪問時，2Q算法將數據緩存在FIFO隊列里面，當數據第二次被訪問時，則將數據從FIFO隊列移到LRU隊列里面，兩個隊列各自按照自己的方法淘汰數據。詳細實現如下：

2Q.png

1. 新訪問的數據插入到FIFO隊列；

2. 如果數據在FIFO隊列中一直沒有被再次訪問，則最終按照FIFO規則淘汰；

3. 如果數據在FIFO隊列中被再次訪問，則將數據移到LRU隊列頭部；

4. 如果數據在LRU隊列再次被訪問，則將數據移到LRU隊列頭部；

5. LRU隊列淘汰末尾的數據。

注：上圖中FIFO隊列比LRU隊列短，但并不代表這是算法要求，實際應用中兩者比例沒有硬性規定。

3.3. 分析

【命中率】

2Q算法的命中率要高于LRU。

【復雜度】

需要兩個隊列，但兩個隊列本身都比較簡單。

【代價】

FIFO和LRU的代價之和。

2Q算法和LRU-2算法命中率類似，內存消耗也比較接近，但對于最后緩存的數據來說，2Q會減少一次從原始存儲讀取數據或者計算數據的操作。

4. Multi Queue（MQ）

4.1. 原理

MQ算法根據訪問頻率將數據劃分為多個隊列，不同的隊列具有不同的訪問優先級，其核心思想是：優先緩存訪問次數多的數據。

4.2. 實現

MQ算法將緩存劃分為多個LRU隊列，每個隊列對應不同的訪問優先級。訪問優先級是根據訪問次數計算出來的，例如

詳細的算法結構圖如下，Q0，Q1....Qk代表不同的優先級隊列，Q-history代表從緩存中淘汰數據，但記錄了數據的索引和引用次數的隊列：

MQ.png

如上圖，算法詳細描述如下：

1. 新插入的數據放入Q0；

2. 每個隊列按照LRU管理數據；

3. 當數據的訪問次數達到一定次數，需要提升優先級時，將數據從當前隊列刪除，加入到高一級隊列的頭部；

4. 為了防止高優先級數據永遠不被淘汰，當數據在指定的時間里訪問沒有被訪問時，需要降低優先級，將數據從當前隊列刪除，加入到低一級的隊列頭部；

5. 需要淘汰數據時，從最低一級隊列開始按照LRU淘汰；每個隊列淘汰數據時，將數據從緩存中刪除，將數據索引加入Q-history頭部；

6. 如果數據在Q-history中被重新訪問，則重新計算其優先級，移到目標隊列的頭部；

7. Q-history按照LRU淘汰數據的索引。

4.3. 分析

【命中率】

MQ降低了“緩存污染”帶來的問題，命中率比LRU要高。

【復雜度】

MQ需要維護多個隊列，且需要維護每個數據的訪問時間，復雜度比LRU高。

【代價】

MQ需要記錄每個數據的訪問時間，需要定時掃描所有隊列，代價比LRU要高。

注：雖然MQ的隊列看起來數量比較多，但由于所有隊列之和受限于緩存容量的大小，因此這里多個隊列長度之和和一個LRU隊列是一樣的，因此隊列掃描性能也相近。

LRU算法對比

對比點 對比
命中率 LRU-2 > MQ(2) > 2Q > LRU
復雜度 LRU-2 > MQ(2) > 2Q > LRU
代價 LRU-2 > MQ(2) > 2Q > LRU
實際應用中需要根據業務的需求和對數據的訪問情況進行選擇，并不是命中率越高越好。例如：雖然LRU看起來命中率會低一些，且存在”緩存污染“的問題，但由于其簡單和代價小，實際應用中反而應用更多。

java中最簡單的LRU算法實現，就是利用jdk的LinkedHashMap，覆寫其中的removeEldestEntry(Map.Entry)方法即可

如果你去看LinkedHashMap的源碼可知，LRU算法是通過雙向鏈表來實現，當某個位置被命中，通過調整鏈表的指向將該位置調整到頭位置，新加入的內容直接放在鏈表頭，如此一來，最近被命中的內容就向鏈表頭移動，需要替換時，鏈表最后的位置就是最近最少使用的位置。

import java.util.ArrayList;  
import java.util.Collection;  
import java.util.LinkedHashMap;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
import java.util.Map;  
   
   
/** 
 * 類說明：利用LinkedHashMap實現簡單的緩存， 必須實現removeEldestEntry方法，具體參見JDK文檔 
 *  
 * @author dennis 
 *  
 * @param <K> 
 * @param <V> 
 */ 
public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {  
    private final int maxCapacity;  
   
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;  
   
    private final Lock lock = new ReentrantLock();  
   
    public LRULinkedHashMap(int maxCapacity) {  
        super(maxCapacity, DEFAULT_LOAD_FACTOR, true);  
        this.maxCapacity = maxCapacity;  
    }  
   
    @Override 
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {  
        return size() > maxCapacity;  
    }  
    @Override 
    public boolean containsKey(Object key) {  
        try {  
            lock.lock();  
            return super.containsKey(key);  
        } finally {  
            lock.unlock();  
        }  
    }  
   
       
    @Override 
    public V get(Object key) {  
        try {  
            lock.lock();  
            return super.get(key);  
        } finally {  
            lock.unlock();  
        }  
    }  
   
    @Override 
    public V put(K key, V value) {  
        try {  
            lock.lock();  
            return super.put(key, value);  
        } finally {  
            lock.unlock();  
        }  
    }  
   
    public int size() {  
        try {  
            lock.lock();  
            return super.size();  
        } finally {  
            lock.unlock();  
        }  
    }  
   
    public void clear() {  
        try {  
            lock.lock();  
            super.clear();  
        } finally {  
            lock.unlock();  
        }  
    }  
   
    public Collection<Map.Entry<K, V>> getAll() {  
        try {  
            lock.lock();  
            return new ArrayList<Map.Entry<K, V>>(super.entrySet());  
        } finally {  
            lock.unlock();  
        }  
    }  
}  

基于雙鏈表 的LRU實現:

傳統意義的LRU算法是為每一個Cache對象設置一個計數器，每次Cache命中則給計數器+1，而Cache用完，需要淘汰舊內容，放置新內容時，就查看所有的計數器，并將最少使用的內容替換掉。

它的弊端很明顯，如果Cache的數量少，問題不會很大， 但是如果Cache的空間過大，達到10W或者100W以上，一旦需要淘汰，則需要遍歷所有計算器，其性能與資源消耗是巨大的。效率也就非常的慢了。

它的原理： 將Cache的所有位置都用雙連表連接起來，當一個位置被命中之后，就將通過調整鏈表的指向，將該位置調整到鏈表頭的位置，新加入的Cache直接加到鏈表頭中。

 這樣，在多次進行Cache操作后，最近被命中的，就會被向鏈表頭方向移動，而沒有命中的，而想鏈表后面移動，鏈表尾則表示最近最少使用的Cache。

 當需要替換內容時候，鏈表的最后位置就是最少被命中的位置，我們只需要淘汰鏈表最后的部分即可。

上面說了這么多的理論， 下面用代碼來實現一個LRU策略的緩存。

我們用一個對象來表示Cache，并實現雙鏈表，

public class LRUCache {  
    /** 
     * 鏈表節點 
     * @author Administrator 
     * 
     */  
    class CacheNode {  
        ……  
    }  
    private int cacheSize;//緩存大小  
    private Hashtable nodes;//緩存容器  
    private int currentSize;//當前緩存對象數量  
    private CacheNode first;//(實現雙鏈表)鏈表頭  
    private CacheNode last;//(實現雙鏈表)鏈表尾  
}  

下面給出完整的實現，這個類也被Tomcat所使用（ org.apache.tomcat.util.collections.LRUCache），但是在tomcat6.x版本中，已經被棄用，使用另外其他的緩存類來替代它。

public class LRUCache {  
    /** 
     * 鏈表節點 
     * @author Administrator 
     * 
     */  
    class CacheNode {  
        CacheNode prev;//前一節點  
        CacheNode next;//后一節點  
        Object value;//值  
        Object key;//鍵  
        CacheNode() {  
        }  
    }  
    public LRUCache(int i) {  
        currentSize = 0;  
        cacheSize = i;  
        nodes = new Hashtable(i);//緩存容器  
    }  
      
    /** 
     * 獲取緩存中對象 
     * @param key 
     * @return 
     */  
    public Object get(Object key) {  
        CacheNode node = (CacheNode) nodes.get(key);  
        if (node != null) {  
            moveToHead(node);  
            return node.value;  
        } else {  
            return null;  
        }  
    }  
      
    /** 
     * 添加緩存 
     * @param key 
     * @param value 
     */  
    public void put(Object key, Object value) {  
        CacheNode node = (CacheNode) nodes.get(key);  
          
        if (node == null) {  
            //緩存容器是否已經超過大小.  
            if (currentSize >= cacheSize) {  
                if (last != null)//將最少使用的刪除  
                    nodes.remove(last.key);  
                removeLast();  
            } else {  
                currentSize++;  
            }  
              
            node = new CacheNode();  
        }  
        node.value = value;  
        node.key = key;  
        //將最新使用的節點放到鏈表頭，表示最新使用的.  
        moveToHead(node);  
        nodes.put(key, node);  
    }  
    /** 
     * 將緩存刪除 
     * @param key 
     * @return 
     */  
    public Object remove(Object key) {  
        CacheNode node = (CacheNode) nodes.get(key);  
        if (node != null) {  
            if (node.prev != null) {  
                node.prev.next = node.next;  
            }  
            if (node.next != null) {  
                node.next.prev = node.prev;  
            }  
            if (last == node)  
                last = node.prev;  
            if (first == node)  
                first = node.next;  
        }  
        return node;  
    }  
    public void clear() {  
        first = null;  
        last = null;  
    }  
    /** 
     * 刪除鏈表尾部節點 
     *  表示 刪除最少使用的緩存對象 
     */  
    private void removeLast() {  
        //鏈表尾不為空,則將鏈表尾指向null. 刪除連表尾（刪除最少使用的緩存對象）  
        if (last != null) {  
            if (last.prev != null)  
                last.prev.next = null;  
            else  
                first = null;  
            last = last.prev;  
        }  
    }  
      
    /** 
     * 移動到鏈表頭，表示這個節點是最新使用過的 
     * @param node 
     */  
    private void moveToHead(CacheNode node) {  
        if (node == first)  
            return;  
        if (node.prev != null)  
            node.prev.next = node.next;  
        if (node.next != null)  
            node.next.prev = node.prev;  
        if (last == node)  
            last = node.prev;  
        if (first != null) {  
            node.next = first;  
            first.prev = node;  
        }  
        first = node;  
        node.prev = null;  
        if (last == null)  
            last = first;  
    }  
    private int cacheSize;  
    private Hashtable nodes;//緩存容器  
    private int currentSize;  
    private CacheNode first;//鏈表頭  
    private CacheNode last;//鏈表尾  
}

原文地址：http://flychao88.iteye.com/blog/1977653