緩存淘汰算法--LRU算法(轉)


(轉自:http://flychao88.iteye.com/blog/1977653)

1. LRU
1.1. 原理

LRU(Least recently used,最近最少使用)算法根據數據的歷史訪問記錄來進行淘汰數據,其核心思想是“如果數據最近被訪問過,那么將來被訪問的幾率也更高”。

1.2. 實現

最常見的實現是使用一個鏈表保存緩存數據,詳細算法實現如下:

1. 新數據插入到鏈表頭部;

2. 每當緩存命中(即緩存數據被訪問),則將數據移到鏈表頭部;

3. 當鏈表滿的時候,將鏈表尾部的數據丟棄。

1.3. 分析

【命中率】

當存在熱點數據時,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次訪問時間距當前時間最大的數據。詳細實現如下:

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隊列里面,兩個隊列各自按照自己的方法淘汰數據。詳細實現如下:

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代表從緩存中淘汰數據,但記錄了數據的索引和引用次數的隊列:

 

如上圖,算法詳細描述如下:

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隊列是一樣的,因此隊列掃描性能也相近。

 

5. 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算法是通過雙向鏈表來實現,當某個位置被命中,通過調整鏈表的指向將該位置調整到頭位置,新加入的內容直接放在鏈表頭,如此一來,最近被命中的內容就向鏈表頭移動,需要替換時,鏈表最后的位置就是最近最少使用的位置。
 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    
 9 /** 
10  * 類說明:利用LinkedHashMap實現簡單的緩存, 必須實現removeEldestEntry方法,具體參見JDK文檔 
11  *  
12  * @author dennis 
13  *  
14  * @param <K> 
15  * @param <V> 
16  */ 
17 public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {  
18     private final int maxCapacity;  
19    
20     private static final float DEFAULT_LOAD_FACTOR = 0.75f;  
21    
22     private final Lock lock = new ReentrantLock();  
23    
24     public LRULinkedHashMap(int maxCapacity) {  
25         super(maxCapacity, DEFAULT_LOAD_FACTOR, true);  
26         this.maxCapacity = maxCapacity;  
27     }  
28    
29     @Override 
30     protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {  
31         return size() > maxCapacity;  
32     }  
33     @Override 
34     public boolean containsKey(Object key) {  
35         try {  
36             lock.lock();  
37             return super.containsKey(key);  
38         } finally {  
39             lock.unlock();  
40         }  
41     }  
42    
43        
44     @Override 
45     public V get(Object key) {  
46         try {  
47             lock.lock();  
48             return super.get(key);  
49         } finally {  
50             lock.unlock();  
51         }  
52     }  
53    
54     @Override 
55     public V put(K key, V value) {  
56         try {  
57             lock.lock();  
58             return super.put(key, value);  
59         } finally {  
60             lock.unlock();  
61         }  
62     }  
63    
64     public int size() {  
65         try {  
66             lock.lock();  
67             return super.size();  
68         } finally {  
69             lock.unlock();  
70         }  
71     }  
72    
73     public void clear() {  
74         try {  
75             lock.lock();  
76             super.clear();  
77         } finally {  
78             lock.unlock();  
79         }  
80     }  
81    
82     public Collection<Map.Entry<K, V>> getAll() {  
83         try {  
84             lock.lock();  
85             return new ArrayList<Map.Entry<K, V>>(super.entrySet());  
86         } finally {  
87             lock.unlock();  
88         }  
89     }  
90 }  

基於雙鏈表 的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;//鏈表尾
}<br style="margin: 0px; padding: 0px;"><br style="margin: 0px; padding: 0px;">

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM