LRU緩存淘汰算法

時間  2019-12-09
標籤 lru 緩存 淘汰 算法 简体版
原文   原文鏈接

最經常使用的緩存淘汰算法看以下連接，再也不贅述html

http://blog.163.com/shi_shun/blog/static/237078492010420320196/java

http://www.cnblogs.com/dolphin0520/p/3749259.htmlnode

http://www.open-open.com/lib/view/open1401935263431.html算法

 

這裏主要是看到一篇專門介紹LRU的博文，受益不淺，收藏一下。apache

摘自：http://flychao88.iteye.com/blog/1977653緩存

1. LRU
1.1. 原理

LRU（Least recently used，最近最少使用）算法根據數據的歷史訪問記錄來進行淘汰數據，其核心思想是「若是數據最近被訪問過，那麼未來被訪問的概率也更高」。tomcat

1.2. 實現

最多見的實現是使用一個鏈表保存緩存數據，詳細算法實現以下：ide

1. 新數據插入到鏈表頭部；性能

2. 每當緩存命中（即緩存數據被訪問），則將數據移到鏈表頭部；this

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
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，並實現雙鏈表，

Java代碼   收藏代碼
  1. public class LRUCache {  
  2.     /** 
  3.      * 鏈表節點 
  4.      * @author Administrator 
  5.      * 
  6.      */  
  7.     class CacheNode {  
  8.         ……  
  9.     }  
  10.     private int cacheSize;//緩存大小  
  11.     private Hashtable nodes;//緩存容器  
  12.     private int currentSize;//當前緩存對象數量  
  13.     private CacheNode first;//(實現雙鏈表)鏈表頭  
  14.     private CacheNode last;//(實現雙鏈表)鏈表尾  
  15. }  
  16.                     

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

Java代碼   收藏代碼
  1. public class LRUCache {  
  2.     /** 
  3.      * 鏈表節點 
  4.      * @author Administrator 
  5.      * 
  6.      */  
  7.     class CacheNode {  
  8.         CacheNode prev;//前一節點  
  9.         CacheNode next;//後一節點  
  10.         Object value;//值  
  11.         Object key;//鍵  
  12.         CacheNode() {  
  13.         }  
  14.     }  
  15.     public LRUCache(int i) {  
  16.         currentSize = 0;  
  17.         cacheSize = i;  
  18.         nodes = new Hashtable(i);//緩存容器  
  19.     }  
  20.       
  21.     /** 
  22.      * 獲取緩存中對象 
  23.      * @param key 
  24.      * @return 
  25.      */  
  26.     public Object get(Object key) {  
  27.         CacheNode node = (CacheNode) nodes.get(key);  
  28.         if (node != null) {  
  29.             moveToHead(node);  
  30.             return node.value;  
  31.         } else {  
  32.             return null;  
  33.         }  
  34.     }  
  35.       
  36.     /** 
  37.      * 添加緩存 
  38.      * @param key 
  39.      * @param value 
  40.      */  
  41.     public void put(Object key, Object value) {  
  42.         CacheNode node = (CacheNode) nodes.get(key);  
  43.           
  44.         if (node == null) {  
  45.             //緩存容器是否已經超過大小.  
  46.             if (currentSize >= cacheSize) {  
  47.                 if (last != null)//將最少使用的刪除  
  48.                     nodes.remove(last.key);  
  49.                 removeLast();  
  50.             } else {  
  51.                 currentSize++;  
  52.             }  
  53.               
  54.             node = new CacheNode();  
  55.         }  
  56.         node.value = value;  
  57.         node.key = key;  
  58.         //將最新使用的節點放到鏈表頭，表示最新使用的.  
  59.         moveToHead(node);  
  60.         nodes.put(key, node);  
  61.     }  
  62.     /** 
  63.      * 將緩存刪除 
  64.      * @param key 
  65.      * @return 
  66.      */  
  67.     public Object remove(Object key) {  
  68.         CacheNode node = (CacheNode) nodes.get(key);  
  69.         if (node != null) {  
  70.             if (node.prev != null) {  
  71.                 node.prev.next = node.next;  
  72.             }  
  73.             if (node.next != null) {  
  74.                 node.next.prev = node.prev;  
  75.             }  
  76.             if (last == node)  
  77.                 last = node.prev;  
  78.             if (first == node)  
  79.                 first = node.next;  
  80.         }  
  81.         return node;  
  82.     }  
  83.     public void clear() {  
  84.         first = null;  
  85.         last = null;  
  86.     }  
  87.     /** 
  88.      * 刪除鏈表尾部節點 
  89.      *  表示 刪除最少使用的緩存對象 
  90.      */  
  91.     private void removeLast() {  
  92.         //鏈表尾不爲空,則將鏈表尾指向null. 刪除連表尾（刪除最少使用的緩存對象）  
  93.         if (last != null) {  
  94.             if (last.prev != null)  
  95.                 last.prev.next = null;  
  96.             else  
  97.                 first = null;  
  98.             last = last.prev;  
  99.         }  
  100.     }  
  101.       
  102.     /** 
  103.      * 移動到鏈表頭，表示這個節點是最新使用過的 
  104.      * @param node 
  105.      */  
  106.     private void moveToHead(CacheNode node) {  
  107.         if (node == first)  
  108.             return;  
  109.         if (node.prev != null)  
  110.             node.prev.next = node.next;  
  111.         if (node.next != null)  
  112.             node.next.prev = node.prev;  
  113.         if (last == node)  
  114.             last = node.prev;  
  115.         if (first != null) {  
  116.             node.next = first;  
  117.             first.prev = node;  
  118.         }  
  119.         first = node;  
  120.         node.prev = null;  
  121.         if (last == null)  
  122.             last = first;  
  123.     }  
  124.     private int cacheSize;  
  125.     private Hashtable nodes;//緩存容器  
  126.     private int currentSize;  
  127.     private CacheNode first;//鏈表頭  
  128.     private CacheNode last;//鏈表尾  
  129. }<br style="margin: 0px; padding: 0px;"><br style="margin: 0px; padding: 0px;">  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程