LRU算法與LRUCache

　　關於LRU

---

 

　　LRU（Least recently used，最近最少使用）算法是操作系統中一種經典的頁面置換算法，當發生缺頁中斷時，需要將內存的一個或幾個頁面置換出，LRU指出應該將內存最近最少使用的那些頁面換出，依據的是程序的局部性原理，最近經常使用的頁面再不久的將來也很有可能被使用，反之最近很少使用的頁面未來也不太可能在使用。

　　其核心思想是“如果數據最近被訪問過，那么將來被訪問的幾率也更高”。但此算法不能保證過去不常用，將來也不常用。

　　設計目標

---

 

　　1、實現LRU算法。

　　2、學以致用，了解算法實際應用場景。

　　3、封裝LRUCache數據結構。

　　4、實現線程安全與線程不安全兩種版本LRUCache。

　實際應用LRU

---

 　　LRU算法非常實用，不僅在操作系統中發揮着很大作用，而且他還是一款緩存淘汰算法。

　　在做大型軟件或網站服務時，如果想要讓系統穩定並且能夠承受得住千萬級用戶的高並發訪問，就要盡量縮短因日常維護操作（計划）和突發的系統崩潰（非計划）所導致的停機時間，以提高系統和應用的可用性。那么我們必然要采取一些高可用的措施。

　　有人說互聯網用戶是用腳投票的，這句話其實也從側面說明了，用戶體驗是多么的重要。這就要求在軟件架構設計時，不但要注重可靠性、安全性、可擴展性以及可維護性等等的一些指標，更要注重用戶的體驗，用戶體驗分很多方面，但是有一點非常重要就是對用戶操作的響應一定要快。怎樣提高用戶訪問的響應速度，這就是擺在架構設計中必須要解決的問題。說道提高服務的響應速度就不得不說緩存了。

　　緩存有三種：數據庫緩存、靜態緩存和動態緩存。

　　從系統的層面說，CPU的速度遠遠高於磁盤IO的速度。所以要想提高響應速度，必須減少磁盤IO的操作，但是有很多信息又是存在數據庫當中的，每次查詢數據庫就是一次IO操作。

　　在目前主流的memcache和redis中都有LRU算法的身影。在兩大中間件中，LRU算法都在他們之中起到緩存回收的作用。關於他們的源碼以后打算分析。

　　靜態緩存：一般指 web 類應用中，將圖片、js、css、視頻、html等靜態文件/資源通過磁盤/內存等緩存方式，提高資源響應方式，減少服務器壓力/資源開銷的一門緩存技術。靜態緩存技術：CDN是經典代表之作。靜態緩存技術面非常廣，涉及的開源技術包含apache、Lighttpd、nginx、varnish、squid等。

　　動態緩存：用於臨時文件交換，緩存是指臨時文件交換區，電腦把最常用的文件從存儲器里提出來臨時放在緩存里，就像把工具和材料搬上工作台一樣，這樣會比用時現去倉庫取更方便。

　　LRU算法過程

---

     鏈表+容器實現LRU緩存

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

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

　　效率也就非常的慢了。

　　所以采用雙向鏈表+hash表的數據結構實現，雙向鏈表作為隊列存儲當前緩存節點，其中從表頭到表尾的元素按照最近使用的時間進行排列，放在表頭的是最近剛剛被使用過的元素，表尾的最近最少使用的元素；如果僅僅采用雙向鏈表，那么查詢某個元素需要 O(n) 的時間，為了加快雙向鏈表中元素的查詢速度，采用hash表講key進行映射，可以在O(1)的時間內找到需要節點。

　　

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

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

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

　　【命中率】　

　　命中率=命中數/（命中數+沒有命中數）， 緩存命中率是判斷加速效果好壞的重要因素之一。

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

　　 

　　　　

　　

　　原理： 將Cache的所有位置都用雙連表連接起來，當一個位置被命中之后，就將通過調整鏈表的指向，將該位置調整到鏈表頭的位置，新加入的Cache直接加到鏈表頭中。 
這樣，在多次進行Cache操作后，最近被命中的，就會被向鏈表頭方向移動，而沒有命中的，而想鏈表后面移動，鏈表尾則表示最近最少使用的Cache。 
當需要替換內容時候，鏈表的最后位置就是最少被命中的位置，我們只需要淘汰鏈表最后的部分即可。

　　

package com.zuo.lru;

import java.util.HashMap;

/**
 * 
 * @author zuo
 *    線程不安全
 * @param <K>
 * @param <V>
 */
public class LRUCache<K, V> {

    private int currentCacheSize;    //當前緩存大小
    private int CacheCapcity;        //緩存上限
    private HashMap<K, CacheNode> caches; //緩存表
    private CacheNode first;    
    private CacheNode last;
    
    public LRUCache(int size) {
        currentCacheSize=0;
        this.CacheCapcity=size;
        caches=new HashMap<K,CacheNode>(size);
    }
    
    /**
     * 添加
     * @param k
     * @param v
     */
    public void put(K k,V v){
        CacheNode node=caches.get(k);
        if(node==null){
            if(caches.size()>=CacheCapcity){
                caches.remove(last.key);
                removeLast();
            }
            node=new CacheNode();
            node.key=k;
        }
        node.value=v;
        moveToFirst(node);
        caches.put(k, node);
    }
    
    public Object get(K k){
        CacheNode node=caches.get(k);
        if(node==null){
            return null;
        }
        moveToFirst(node);
        return node.value;
    }
    
    /**
     * 刪除
     * @param k
     * @return
     */
    public Object remove(K k){
        CacheNode node=caches.get(k);
        if(node!=null){
            if(node.pre!=null){
                node.pre.next=node.next;//前結點的后指針指向當前節點的下一個
            }
            if(node.next!=null){
                node.next.pre=node.pre;//后節點的前指針指向當前結點的上一個
            }
            if(node==first){
                first=node.next;
            }
            if(node==last){
                last=node.pre;
            }
        }
        return caches.remove(k);
    }
    
    /**
     * 刪除last
     */
    private void removeLast(){
        if(last!=null){
            last=last.pre;
            if(last==null){
                first=null;
            }else{
                last.next=null;
            }
        }
    }
    
    /**
     * 將node移動到頭說明使用頻率高
     * @param node
     */
    private void moveToFirst(CacheNode node){
        if(first==node){
            return;
        }
        if(node.pre!=null){
            node.pre.next=node.next;//前結點的后指針指向當前節點的下一個
        }
        if(node.next!=null){
            node.next.pre=node.pre;//后節點的前指針指向當前結點的上一個
        }
        if(node==last){
            last=last.pre;
        }
        if(first==null || last==null){
            first=last=node;
            return;
        }
        node.next=first;
        first.pre=node;
        first=node;
        first.pre=null;
    }
    
    
    
    /**
     * 清空
     */
    public void clear(){
        first=null;
        last=null;
        caches.clear();
    }
    
    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder();
        CacheNode node=first;
        while(node!=null){
            stringBuilder.append(String.format("%s:%s ", node.key,node.value));
            node=node.next;
        }
        return stringBuilder.toString();
    }
    
    /**
     * @author zuo
     * 雙向鏈表
     */
    class CacheNode{
        CacheNode pre; //前指針
        CacheNode next;//后指針
        Object key;    //鍵
        Object value;  //值
        public CacheNode() {
        }
    }
    
    public int getCurrentCacheSize() {
        return currentCacheSize;
    }
    

    public static void main(String[] args) {

        LRUCache<Integer,String> lru = new LRUCache<Integer,String>(3);

        lru.put(1, "a");    // 1:a
        System.out.println(lru.toString());
        lru.put(2, "b");    // 2:b 1:a 
        System.out.println(lru.toString());
        lru.put(3, "c");    // 3:c 2:b 1:a 
        System.out.println(lru.toString());
        lru.put(4, "d");    // 4:d 3:c 2:b  
        System.out.println(lru.toString());
        lru.put(1, "aa");   // 1:aa 4:d 3:c  
        System.out.println(lru.toString());
        lru.put(2, "bb");   // 2:bb 1:aa 4:d
        System.out.println(lru.toString());
        lru.put(5, "e");    // 5:e 2:bb 1:aa
        System.out.println(lru.toString());
        lru.get(1);         // 1:aa 5:e 2:bb
        System.out.println(lru.toString());
        lru.remove(11);     // 1:aa 5:e 2:bb
        System.out.println(lru.toString());
        lru.remove(1);      //5:e 2:bb
        System.out.println(lru.toString());
        lru.put(1, "aaa");  //1:aaa 5:e 2:bb
        System.out.println(lru.toString());
    }
    
    
    
}

 

　　線程安全與線程不安全

---

　　

　　線程安全就是多線程訪問時，采用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。
　　線程不安全就是不提供數據訪問保護，有可能出現多個線程先后更改數據造成所得到的數據是臟數據。　　

package com.zuo.lru;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 線程安全
 * @author zuo
 *
 */
public class LRUCacheSafe <K,V>{
    
    private final LinkedHashMap<K,V> map;
    
    private int currentCacheSize;    //當前cache的大小
    private int CacheCapcity; //cache最大大小
    private int putCount;       //put的次數
    private int createCount;    //create的次數
    private int evictionCount;  //回收的次數
    private int hitCount;       //命中的次數
    private int missCount;      //未命中次數
    
    public LRUCacheSafe(int CacheCapcity){
        if(CacheCapcity<=0){
            throw new IllegalArgumentException("CacheCapcity <= 0");
        }
        this.CacheCapcity=CacheCapcity;
        //將LinkedHashMap的accessOrder設置為true來實現LRU
        this.map=new LinkedHashMap<K,V>(0,0.75f,true);//true 就是基於訪問的順序，get一個元素后，這個元素被加到最后(使用了LRU 最近最少被使用的調度算法)
    }
    
    public final V get(K key){
        if(key==null){
            throw new NullPointerException("key == null");
        }
        V mapValue;
        synchronized (this) {
            mapValue=map.get(key);
            if(mapValue!=null){
                //mapValue 不為空表示命中，hitCount+1 並返回mapValue對象
                hitCount++;
                return mapValue;
            }
            missCount++;
        }
        //如果未命中，則試圖創建一個對象，這里create方法放回null，並沒有實現創建對象的方法
        //如果需要事項創建對象的方法可以重寫create方法。因為圖片緩存時內存緩存沒有命中會去文件緩存或者從網絡下載，所以不需要創建。
        V createValue=create(key);
        if(createValue==null){
            return null;
        }
        //假如創建了新的對象，則繼續往下運行
        synchronized (this) {
            createCount++;
            //將createValue加入到map中，並且將原來的key的對象保存到mapValue
            mapValue=map.put(key, createValue);
            if(mapValue!=null){
                //如果mapValue不為空，則撤銷上一步的put操作
                map.put(key, mapValue);
            }else{
                //加入新創建的對象之后需要重新計算currentCacheSize大小
                currentCacheSize+=safecurrentCacheSizeOf(key, createValue);
            }
        }
        if(mapValue!=null){
            entryRemoved(false, key, createValue, mapValue);
            return mapValue;
        }else{
            //每次新加入對象都需要調用trimTocurrentCacheSize方法看是否回收
            trimTocurrentCacheSize(CacheCapcity);
            return createValue;
        }
    }
    
    /**
     * 此方法根據CacheCapcity來調整cache的大小，如果CacheCapcity傳入-1，則清空緩存中的的大小
     * @param CacheCapcity
     */
    private void trimTocurrentCacheSize(int CacheCapcity){
        while(true){
            K key;
            V value;
            synchronized (this) {
                if(currentCacheSize<0||(map.isEmpty() && currentCacheSize!=0)){
                    throw new IllegalStateException(getClass().getName()
                         + ".currentCacheSizeOf() is reporting inconsistent results!");
                }
                //如果當前currentCacheSize小於CacheCapcity或者map沒有任何對象，則循環結束
                if(currentCacheSize<=CacheCapcity || map.isEmpty()){
                    break;
                }
                //移除鏈表頭部的元素，並進入下一次循環
                Map.Entry<K, V> toEvict =map.entrySet().iterator().next();
                key=toEvict.getKey();
                value=toEvict.getValue();
                map.remove(key);
                currentCacheSize-=safecurrentCacheSizeOf(key, value);
                evictionCount++;//回收次數++
            }
            entryRemoved(true, key, value, null);
        }
    }
    
    public final V put(K key,V value){
        if(key==null||value==null){
            throw new NullPointerException("key == null || value == null");
        }
        V previous;
        synchronized (this) {
            putCount++;
            currentCacheSize+=safecurrentCacheSizeOf(key, value);//currentCacheSize加上預put對象大小
            previous=map.put(key, value);
            if(previous!=null){
                //如果之前存在鍵為key的對象，則currentCacheSize應該減去原來對象的大小
                currentCacheSize-=safecurrentCacheSizeOf(key, previous);
            }
        }
        if(previous!=null){
            entryRemoved(false, key, previous, value);
        }
        //每次新加入的對象都需要調用trimtocurrentCacheSize方法看是否要回收
        trimTocurrentCacheSize(CacheCapcity);
        return previous;
    }
    
    /**
     * 從內存緩存中根據key值移除某個對象並返回該對象
     * @param key
     * @return
     */
    public final V remove(K key){
        if(key==null){
            throw new NullPointerException("key == null");
        }
        V previous;
        synchronized (this) {
            previous=map.remove(key);
            if(previous!=null){
                currentCacheSize-=safecurrentCacheSizeOf(key, previous);
            }
        }
        if(previous!=null){
            entryRemoved(false, key, previous, null);
        }
        return previous;
    }
    
    /**
     * 在高速緩存未命中之后調用以計算對應鍵的值
     * @param key
     * @return 如果沒有計算值，則返回計算值或NULL
     */
    protected V create(K key) {
        return null;
    }
    
    private int safecurrentCacheSizeOf(K key,V value){
        int result=currentCacheSizeOf(key, value);
        if(result<0){
            throw new IllegalStateException("Negative currentCacheSize: " + key + "=" + value);
        }
        return result;
    }
    
    /**
     * 用來計算單個對象的大小，這里默認返回1
     * @param key
     * @param value
     * @return
     */
    protected int currentCacheSizeOf(K key,V value) {
        return 1;
    }
    
    protected void entryRemoved(boolean evicted,K key,V oldValue,V newValue) {}
    
    /**
     * 清空內存緩存
     */
    public final void evictAll(){
        trimTocurrentCacheSize(-1);
    }
    
    /**
     * 當前cache大小
     * @return
     */
    public synchronized final int currentCacheSize(){
        return currentCacheSize;
    }
    /**
     * 命中次數
     * @return
     */
    public synchronized final int hitCount(){
        return hitCount;
    }
    /**
     * 未命中次數
     * @return
     */
    public synchronized final int missCount(){
        return missCount;
    }
    /**
     * create次數
     * @return
     */
    public synchronized final int createCount(){
        return createCount;
    }
    /**
     * put次數
     * @return
     */
    public synchronized final int putCount(){
        return putCount;
    }
    /**
     * 回收次數
     * @return
     */
    public synchronized final int evictionCount(){
        return evictionCount;
    }
    /**
     * 返回一個當前緩存內容的副本
     * @return
     */
    public synchronized final Map<K, V> snapshot(){
        return new LinkedHashMap<K,V>(map);
    }
    
    @Override
    public synchronized final String toString() {
        int accesses =hitCount+missCount;
        int hitPercent=accesses!=0?(100 * hitCount/accesses):0;//緩存命中率是判斷加速效果好壞的重要因素
        Iterator<Entry<K, V>> iterator= map.entrySet().iterator();  
        while(iterator.hasNext())  
        {  
            Entry<K, V> entry = iterator.next();  
            System.out.println(entry.getKey()+":"+entry.getValue());  
        } 
        return String.format("LruCache[緩存最大大小=%d,命中次數=%d,未命中次數=%d,命中率=%d%%]",
                        CacheCapcity, hitCount, missCount, hitPercent);
    }
    
    public static void main(String[] args) {

        LRUCacheSafe<Integer,String> lru = new LRUCacheSafe<Integer,String>(3);
        System.out.println("--------------------開始使用LRU緩存---------------");
       
        lru.put(1, "7");    
        System.out.println(lru.toString());
        lru.put(2, "0");    
        System.out.println(lru.toString());
        lru.put(3, "1");    
        System.out.println(lru.toString());
        lru.put(4, "2");     
        System.out.println(lru.toString());
        lru.put(1, "0");   
        System.out.println(lru.toString());
        lru.put(2, "3");   
        System.out.println(lru.toString());
        lru.put(5, "0");   
        System.out.println(lru.toString());
        lru.put(6, "4");   
        System.out.println(lru.toString());
        lru.put(7, "2");   
        System.out.println(lru.toString());
        lru.put(8, "3");   
        System.out.println(lru.toString());
        lru.put(9, "0");   
        System.out.println(lru.toString());
        lru.put(10, "3");   
        System.out.println(lru.toString());
        lru.put(11, "2");   
        System.out.println(lru.toString());
        lru.put(12, "1");   
        System.out.println(lru.toString());
        lru.put(13, "2");   
        System.out.println(lru.toString());
        lru.put(14, "0");   
        System.out.println(lru.toString());
        lru.put(15, "1");   
        System.out.println(lru.toString());
        lru.put(16, "7");   
        System.out.println(lru.toString());
        lru.put(17, "0");   
        System.out.println(lru.toString());
        lru.put(18, "1");   
        System.out.println(lru.toString());
        lru.get(1);         
        lru.get(18);         
        lru.get(2);         
        System.out.println(lru.toString());
        lru.remove(16);     
        System.out.println(lru.toString());
    }

}