精進之路之lru

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

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

1. 新數據插入到鏈表頭部；
2. 每當緩存命中（即緩存數據被訪問），則將數據移到鏈表頭部；
3. 當鏈表滿的時候，將鏈表尾部的數據丟棄。
分析
【命中率】
當存在熱點數據時，LRU的效率很好，但偶發性的、週期性的批量操做會致使LRU命中率急劇降低，緩存污染狀況比較嚴重。
【複雜度】
實現簡單。
【代價】
命中時須要遍歷鏈表，找到命中的數據塊索引，而後須要將數據移到頭部。

 

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

 1 public class LRUCache<K, V> extends LinkedHashMap<K, V> {
 2 
 3     private static final long serialVersionUID = 1L;
 4 
 5     //緩存大小
 6     private int cacheSize;
 7 
 8     public LRUCache(int cacheSize) {
 9         //第三個參數true是關鍵
10         super(10, 0.75f, true);
11         this.cacheSize = cacheSize;
12     }
13 
14     /**
15      * 緩存是否已滿
16      */
17     @Override
18     protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
19         boolean r = size() > cacheSize;
20         if (r) {
21             System.out.println("清除緩存key：" + eldest.getKey());
22         }
23         return r;
24     }
25 
26     //測試
27     public static void main(String[] args) {
28         LRUCache<String, String> cache = new LRUCache<String, String>(5);
29         cache.put("1", "1");
30         cache.put("2", "2");
31         cache.put("3", "3");
32         cache.put("4", "4");
33         cache.put("5", "5");
34 
35         System.out.println("初始化：");
36         System.out.println(cache.keySet());
37         System.out.println("訪問3：");
38         cache.get("3");
39         System.out.println(cache.keySet());
40         System.out.println("訪問2：");
41         cache.get("2");
42         System.out.println(cache.keySet());
43         System.out.println("增長數據6,7：");
44         cache.put("6", "6");
45         cache.put("7", "7");
46         System.out.println(cache.keySet());
47     }

實現2

LRUCache的鏈表+HashMap實現

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

它的弊端很明顯，若是Cache的數量少，問題不會很大， 可是若是Cache的空間過大，達到10W或者100W以上，一旦須要淘汰，則須要遍歷全部計算器，其性能與資源消耗是巨大的。效率也就很是的慢了。
它的原理： 將Cache的全部位置都用雙連錶鏈接起來，當一個位置被命中以後，就將經過調整鏈表的指向，將該位置調整到鏈表頭的位置，新加入的Cache直接加到鏈表頭中。
這樣，在屢次進行Cache操做後，最近被命中的，就會被向鏈表頭方向移動，而沒有命中的，而想鏈表後面移動，鏈表尾則表示最近最少使用的Cache。
當須要替換內容時候，鏈表的最後位置就是最少被命中的位置，咱們只須要淘汰鏈表最後的部分便可。
上面說了這麼多的理論， 下面用代碼來實現一個LRU策略的緩存。
非線程安全，若實現安全，則在響應的方法加鎖。

  1 public class LRUCacheDemo<K, V> {
  2 
  3     private int currentCacheSize;
  4     private int CacheCapcity;
  5     private HashMap<K, CacheNode> caches;
  6     private CacheNode first;
  7     private CacheNode last;
  8 
  9     public LRUCacheDemo(int size) {
 10         currentCacheSize = 0;
 11         this.CacheCapcity = size;
 12         caches = new HashMap<>(size);
 13     }
 14 
 15     public void put(K k, V v) {
 16         CacheNode node = caches.get(k);
 17         if (node == null) {
 18             if (caches.size() >= CacheCapcity) {
 19                 caches.remove(last.key);
 20                 removeLast();
 21             }
 22             node = new CacheNode();
 23             node.key = k;
 24         }
 25         node.value = v;
 26         moveToFirst(node);
 27         caches.put(k, node);
 28     }
 29 
 30     public Object get(K k) {
 31         CacheNode node = caches.get(k);
 32         if (node == null) {
 33             return null;
 34         }
 35         moveToFirst(node);
 36         return node.value;
 37     }
 38 
 39     public Object remove(K k) {
 40         CacheNode node = caches.get(k);
 41         if (node != null) {
 42             if (node.pre != null) {
 43                 node.pre.next = node.next;
 44             }
 45             if (node.next != null) {
 46                 node.next.pre = node.pre;
 47             }
 48             if (node == first) {
 49                 first = node.next;
 50             }
 51             if (node == last) {
 52                 last = node.pre;
 53             }
 54         }
 55         return caches.remove(k);
 56     }
 57 
 58     public void clear() {
 59         first = null;
 60         last = null;
 61         caches.clear();
 62     }
 63 
 64     private void moveToFirst(CacheNode node) {
 65         if (first == node) {
 66             return;
 67         }
 68         if (node.next != null) {
 69             node.next.pre = node.pre;
 70         }
 71         if (node.pre != null) {
 72             node.pre.next = node.next;
 73         }
 74         if (node == last) {
 75             last = last.pre;
 76         }
 77         if (first == null || last == null) {
 78             first = last = node;
 79             return;
 80         }
 81         node.next = first;
 82         first.pre = node;
 83         first = node;
 84         first.pre = null;
 85     }
 86 
 87     private void removeLast() {
 88         if (last != null) {
 89             last = last.pre;
 90             if (last == null) {
 91                 first = null;
 92             } else {
 93                 last.next = null;
 94             }
 95         }
 96     }
 97 
 98     @Override
 99     public String toString() {
100         StringBuilder sb = new StringBuilder();
101         CacheNode node = first;
102         while (node != null) {
103             sb.append(String.format("%s:%s ", node.key, node.value));
104             node = node.next;
105         }
106         return sb.toString();
107     }
108 
109     class CacheNode {
110         CacheNode pre;
111         CacheNode next;
112         Object key;
113         Object value;
114 
115         public CacheNode() {
116         }
117     }
118 
119     public static void main(String[] args) {
120         LRUCache<Integer, String> lru = new LRUCache<Integer, String>(3);
121         lru.put(1, "a"); // 1:a
122         System.out.println(lru.toString());
123         lru.put(2, "b"); // 2:b 1:a
124         System.out.println(lru.toString());
125         lru.put(3, "c"); // 3:c 2:b 1:a 
126         System.out.println(lru.toString());
127         lru.put(4, "d"); // 4:d 3:c 2:b
128         System.out.println(lru.toString());
129         lru.put(1, "aa"); // 1:aa 4:d 3:c
130         System.out.println(lru.toString());
131         lru.put(2, "bb"); // 2:bb 1:aa 4:d
132         System.out.println(lru.toString());
133         lru.put(5, "e"); // 5:e 2:bb 1:aa
134         System.out.println(lru.toString());
135         lru.get(1); // 1:aa 5:e 2:bb
136         System.out.println(lru.toString());
137         lru.remove(11); // 1:aa 5:e 2:bb
138         System.out.println(lru.toString());
139         lru.remove(1); //5:e 2:bb
140         System.out.println(lru.toString());
141         lru.put(1, "aaa"); //1:aaa 5:e 2:bb
142         System.out.println(lru.toString());
143     }
144 }

擴展：

擴展
1.LRU-K
LRU-K中的K表明最近使用的次數，所以LRU能夠認爲是LRU-1。LRU-K的主要目的是爲了解決LRU算法「緩存污染」的問題，其核心思想是將「最近使用過1次」的判斷標準擴展爲「最近使用過K次」。
相比LRU，LRU-K須要多維護一個隊列，用於記錄全部緩存數據被訪問的歷史。只有當數據的訪問次數達到K次的時候，纔將數據放入緩存。當須要淘汰數據時，LRU-K會淘汰第K次訪問時間距當前時間最大的數據。
數據第一次被訪問時，加入到歷史訪問列表，若是數據在訪問歷史列表中沒有達到K次訪問，則按照必定的規則（FIFO,LRU）淘汰；當訪問歷史隊列中的數據訪問次數達到K次後，將數據索引從歷史隊列中刪除，將數據移到緩存隊列中，並緩存數據，緩存隊列從新按照時間排序；緩存數據隊列中被再次訪問後，從新排序，須要淘汰數據時，淘汰緩存隊列中排在末尾的數據，即「淘汰倒數K次訪問離如今最久的數據」。
LRU-K具備LRU的優勢，同時還能避免LRU的缺點，實際應用中LRU-2是綜合最優的選擇。因爲LRU-K還須要記錄那些被訪問過、但尚未放入緩存的對象，所以內存消耗會比LRU要多
 

本文參考整理於  https://blog.csdn.net/wangxilong1991/article/details/70172302 ,https://blog.csdn.net/elricboa/article/details/78847305，感謝原做者的精彩分享！！！