码迷，mamicode.com
首页 > 编程语言 > 详细

LRU缓存介绍与实现 (Java)

时间：2014-06-11 22:32:11      阅读：399      评论：0      收藏：0      [点我收藏+]

标签：des   style   class   blog   code   java   

引子：

我们平时总会有一个电话本记录所有朋友的电话，但是，如果有朋友经常联系，那些朋友的电话号码不用翻电话本我们也能记住，但是，如果长时间没有联系 了，要再次联系那位朋友的时候，我们又不得不求助电话本，但是，通过电话本查找还是很费时间的。但是，我们大脑能够记住的东西是一定的，我们只能记住自己 最熟悉的，而长时间不熟悉的自然就忘记了。

其实，计算机也用到了同样的一个概念，我们用缓存来存放以前读取的数据，而不是直接丢掉，这样，再次读取的时候，可以直接在缓存里面取，而不用再重 新查找一遍，这样系统的反应能力会有很大提高。但是，当我们读取的个数特别大的时候，我们不可能把所有已经读取的数据都放在缓存里，毕竟内存大小是一定 的，我们一般把最近常读取的放在缓存里（相当于我们把最近联系的朋友的姓名和电话放在大脑里一样）。现在，我们就来研究这样一种缓存机制。

LRU缓存：

LRU缓存利用了这样的一种思想。LRU是Least Recently Used 的缩写，翻译过来就是“最近最少使用”，也就是说，LRU缓存把最近最少使用的数据移除，让给最新读取的数据。而往往最常读取的，也是读取次数最多的，所 以，利用LRU缓存，我们能够提高系统的performance.

实现：

要实现LRU缓存，我们首先要用到一个类 LinkedHashMap。 用这个类有两大好处：一是它本身已经实现了按照访问顺序的存储，也就是说，最近读取的会放在最前面，最最不常读取的会放在最后（当然，它也可以实现按照插 入顺序存储）。第二，LinkedHashMap本身有一个方法用于判断是否需要移除最不常读取的数，但是，原始方法默认不需要移除（这 是，LinkedHashMap相当于一个linkedlist），所以，我们需要override这样一个方法，使得当缓存里存放的数据个数超过规定个 数后，就把最不常用的移除掉。LinkedHashMap的API写得很清楚，推荐大家可以先读一下。

要基于LinkedHashMap来实现LRU缓存，我们可以选择inheritance, 也可以选择 delegation， 我更喜欢delegation。基于delegation的实现已经有人写出来了，而且写得很漂亮，我就不班门弄斧了。代码如下：

[java] view plaincopy
  1. import java.util.LinkedHashMap;  
  2. import java.util.Collection;  
  3. import java.util.Map;  
  4. import java.util.ArrayList;  
  5.   
  6. /** 
  7. * An LRU cache, based on <code>LinkedHashMap</code>. 
  8. * 
  9. * <p> 
  10. * This cache has a fixed maximum number of elements (<code>cacheSize</code>). 
  11. * If the cache is full and another entry is added, the LRU (least recently used) entry is dropped. 
  12. * 
  13. * <p> 
  14. * This class is thread-safe. All methods of this class are synchronized. 
  15. * 
  16. * <p> 
  17. * Author: Christian d‘Heureuse, Inventec Informatik AG, Zurich, Switzerland<br> 
  18. * Multi-licensed: EPL / LGPL / GPL / AL / BSD. 
  19. */  
  20. public class LRUCache<K,V> {  
  21.   
  22. private static final float   hashTableLoadFactor = 0.75f;  
  23.   
  24. private LinkedHashMap<K,V>   map;  
  25. private int                  cacheSize;  
  26.   
  27. /** 
  28. * Creates a new LRU cache. 
  29. * @param cacheSize the maximum number of entries that will be kept in this cache. 
  30. */  
  31. public LRUCache (int cacheSize) {  
  32.    this.cacheSize = cacheSize;  
  33.    int hashTableCapacity = (int)Math.ceil(cacheSize / hashTableLoadFactor) + 1;  
  34.    map = new LinkedHashMap<K,V>(hashTableCapacity, hashTableLoadFactor, true) {  
  35.       // (an anonymous inner class)  
  36.       private static final long serialVersionUID = 1;  
  37.       @Override protected boolean removeEldestEntry (Map.Entry<K,V> eldest) {  
  38.          return size() > LRUCache.this.cacheSize; }}; }  
  39.   
  40. /** 
  41. * Retrieves an entry from the cache.<br> 
  42. * The retrieved entry becomes the MRU (most recently used) entry. 
  43. * @param key the key whose associated value is to be returned. 
  44. * @return    the value associated to this key, or null if no value with this key exists in the cache. 
  45. */  
  46. public synchronized V get (K key) {  
  47.    return map.get(key); }  
  48.   
  49. /** 
  50. * Adds an entry to this cache. 
  51. * The new entry becomes the MRU (most recently used) entry. 
  52. * If an entry with the specified key already exists in the cache, it is replaced by the new entry. 
  53. * If the cache is full, the LRU (least recently used) entry is removed from the cache. 
  54. * @param key    the key with which the specified value is to be associated. 
  55. * @param value  a value to be associated with the specified key. 
  56. */  
  57. public synchronized void put (K key, V value) {  
  58.    map.put (key, value); }  
  59.   
  60. /** 
  61. * Clears the cache. 
  62. */  
  63. public synchronized void clear() {  
  64.    map.clear(); }  
  65.   
  66. /** 
  67. * Returns the number of used entries in the cache. 
  68. * @return the number of entries currently in the cache. 
  69. */  
  70. public synchronized int usedEntries() {  
  71.    return map.size(); }  
  72.   
  73. /** 
  74. * Returns a <code>Collection</code> that contains a copy of all cache entries. 
  75. * @return a <code>Collection</code> with a copy of the cache content. 
  76. */  
  77. public synchronized Collection<Map.Entry<K,V>> getAll() {  
  78.    return new ArrayList<Map.Entry<K,V>>(map.entrySet()); }  
  79.   
  80. } // end class LRUCache  
  81. ------------------------------------------------------------------------------------------  
  82. // Test routine for the LRUCache class.  
  83. public static void main (String[] args) {  
  84.    LRUCache<String,String> c = new LRUCache<String, String>(3);  
  85.    c.put ("1", "one");                           // 1  
  86.    c.put ("2", "two");                           // 2 1  
  87.    c.put ("3", "three");                         // 3 2 1  
  88.    c.put ("4", "four");                          // 4 3 2  
  89.    if (c.get("2") == null) throw new Error();    // 2 4 3  
  90.    c.put ("5", "five");                          // 5 2 4  
  91.    c.put ("4", "second four");                   // 4 5 2  
  92.    // Verify cache content.  
  93.    if (c.usedEntries() != 3)              throw new Error();  
  94.    if (!c.get("4").equals("second four")) throw new Error();  
  95.    if (!c.get("5").equals("five"))        throw new Error();  
  96.    if (!c.get("2").equals("two"))         throw new Error();  
  97.    // List cache content.  
  98.    for (Map.Entry<String, String> e : c.getAll())  
  99.       System.out.println (e.getKey() + " : " + e.getValue()); }  


代码出自：http://www.source-code.biz/snippets/java/6.htm


在博客 http://gogole.iteye.com/blog/692103 里，作者使用的是双链表 + hashtable 的方式实现的。如果在面试题里考到如何实现LRU，考官一般会要求使用双链表 + hashtable 的方式。 所以，我把原文的部分内容摘抄如下：


双链表 + hashtable实现原理：

将Cache的所有位置都用双连表连接起来，当一个位置被命中之后，就将通过调整链表的指向，将该位置调整到链表头的位置，新加入的Cache直接 加到链表头中。这样，在多次进行Cache操作后，最近被命中的，就会被向链表头方向移动，而没有命中的，而想链表后面移动，链表尾则表示最近最少使用的 Cache。当需要替换内容时候，链表的最后位置就是最少被命中的位置，我们只需要淘汰链表最后的部分即可。

[java] view plaincopy
  1. public class LRUCache {  
  2.       
  3.     private int cacheSize;  
  4.     private Hashtable<Object, Entry> nodes;//缓存容器  
  5.     private int currentSize;  
  6.     private Entry first;//链表头  
  7.     private Entry last;//链表尾  
  8.       
  9.     public LRUCache(int i) {  
  10.         currentSize = 0;  
  11.         cacheSize = i;  
  12.         nodes = new Hashtable<Object, Entry>(i);//缓存容器  
  13.     }  
  14.       
  15.     /** 
  16.      * 获取缓存中对象,并把它放在最前面 
  17.      */  
  18.     public Entry get(Object key) {  
  19.         Entry node = nodes.get(key);  
  20.         if (node != null) {  
  21.             moveToHead(node);  
  22.             return node;  
  23.         } else {  
  24.             return null;  
  25.         }  
  26.     }  
  27.       
  28.     /** 
  29.      * 添加 entry到hashtable, 并把entry  
  30.      */  
  31.     public void put(Object key, Object value) {  
  32.         //先查看hashtable是否存在该entry, 如果存在，则只更新其value  
  33.         Entry node = nodes.get(key);  
  34.           
  35.         if (node == null) {  
  36.             //缓存容器是否已经超过大小.  
  37.             if (currentSize >= cacheSize) {  
  38.                 nodes.remove(last.key);  
  39.                 removeLast();  
  40.             } else {  
  41.                 currentSize++;  
  42.             }             
  43.             node = new Entry();  
  44.         }  
  45.         node.value = value;  
  46.         //将最新使用的节点放到链表头，表示最新使用的.  
  47.         moveToHead(node);  
  48.         nodes.put(key, node);  
  49.     }  
  50.   
  51.     /** 
  52.      * 将entry删除, 注意：删除操作只有在cache满了才会被执行 
  53.      */  
  54.     public void remove(Object key) {  
  55.         Entry node = nodes.get(key);  
  56.         //在链表中删除  
  57.         if (node != null) {  
  58.             if (node.prev != null) {  
  59.                 node.prev.next = node.next;  
  60.             }  
  61.             if (node.next != null) {  
  62.                 node.next.prev = node.prev;  
  63.             }  
  64.             if (last == node)  
  65.                 last = node.prev;  
  66.             if (first == node)  
  67.                 first = node.next;  
  68.         }  
  69.         //在hashtable中删除  
  70.         nodes.remove(key);  
  71.     }  
  72.   
  73.     /** 
  74.      * 删除链表尾部节点，即使用最后 使用的entry 
  75.      */  
  76.     private void removeLast() {  
  77.         //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）  
  78.         if (last != null) {  
  79.             if (last.prev != null)  
  80.                 last.prev.next = null;  
  81.             else  
  82.                 first = null;  
  83.             last = last.prev;  
  84.         }  
  85.     }  
  86.       
  87.     /** 
  88.      * 移动到链表头，表示这个节点是最新使用过的 
  89.      */  
  90.     private void moveToHead(Entry node) {  
  91.         if (node == first)  
  92.             return;  
  93.         if (node.prev != null)  
  94.             node.prev.next = node.next;  
  95.         if (node.next != null)  
  96.             node.next.prev = node.prev;  
  97.         if (last == node)  
  98.             last = node.prev;  
  99.         if (first != null) {  
  100.             node.next = first;  
  101.             first.prev = node;  
  102.         }  
  103.         first = node;  
  104.         node.prev = null;  
  105.         if (last == null)  
  106.             last = first;  
  107.     }  
  108.     /* 
  109.      * 清空缓存 
  110.      */  
  111.     public void clear() {  
  112.         first = null;  
  113.         last = null;  
  114.         currentSize = 0;  
  115.     }  
  116.   
  117. }  
  118.   
  119. class Entry {  
  120.     Entry prev;//前一节点  
  121.     Entry next;//后一节点  
  122.     Object value;//值  
  123.     Object key;//键  
  124. }  

转载请注明出处：http://blog.csdn.net/beiyeqingteng

LRU缓存介绍与实现 (Java),布布扣,bubuko.com

LRU缓存介绍与实现 (Java)

标签：des   style   class   blog   code   java   

原文地址：http://www.cnblogs.com/xmgh/p/3772300.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！