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());
     }

 }