java中的cache机制
java应用中cache最常用的场合是:将程序或系统经常要调用的对象存在内存中,以便其使用时可以快速调用,不必再去创建新的重复的实例。这样做可以减少系统开销,提高系统效率。一般的用法就是把数据从数据库读到内存,然后之后的数据访问都从内存来读,从而减少对数据库的读取次数来提高效率。
使用cache时,不应涉及业务逻辑,而是单纯的为了提高程序效率。应该保证cache拿掉了程序也能运行,且结果正确!读访问远大于写访问的数据是适合作为cache的!因为写操作是针对数据库的,而读操作是针对cache的,经过一次写操作以后,数据库和cache的数据就会不一致,带来问题。
cache最基本的实现是用HashTable。cache的内存大小是有限的,当内存满时需要一种机制删除cache中旧的数据,其中就有3种机制:最近最少使用算法 Least Recently Used (LRU)、First In, First Out算法、使用次数最小算法 Least Frequently Used (LFU)。下面依次介绍:
一、最近最少使用算法 Least Recently Used (LRU)
这个算法就是把最近一次使用时间离现在时间最远的数据删除掉。常用的方法是HashTable + LinkedList,HashTable作为缓存容器,然后用LinkedList连接所有的entry,这样就实现了顺序,就可以通过一定的算法得到LRU了!
对于LRU cache,往往会有以下要求:
1. 假设Cache里面的 entry 都是按照序列保存的,那么,对于新的entry,我们把它放置在最前面。
2. 如果一个entry已经存在,我们再次访问到该entry的时候,我们需要把它放在cache的最前面。
3. 当cache满了的时候,需要把最后一个entry 从cache里面移除出去,然后再往里插入 entry。
4. 以上所有的操作复杂度必须为 O(1).
对于操作复杂度,一旦看到要求为O(1), 一般我们都会立刻想到 hashtable, 所以,为了实现“顺序”的要求,我们需要有一个链表来连接所有的entry. 所以,在实现时,我们将Cache的所有 entry 都用doubly linked list 连接起来,当一个 entry 被命中之后,就将通过调整链表的指向,将该位置调整到链表头的位置,新加入的Cache直接加到链表头中。这样,在多次进行Cache操作后,最近被命中的,就会被向链表头方向移动,而没有命中的,而想链表后面移动,链表尾则表示最近最少使用的Cache。当需要替换内容时候,链表的最后位置就是最少被命中的位置,我们只需要淘汰链表最后的部分即可。我们首先定义entry, 每一个entry包括键(key)和 值 (value),而且,每一个 entry 都带有两个指针分别指向它们的前一个和后一个 entry。
1 class Entry { 2 Entry prev;//前一节点 3 Entry next;//后一节点 4 Object value;//值 5 Object key;//键 6 }
hashtable里,我们需要保存该entry, 这个时候,我们用entry的键作为hashtable 里的键,而hashtable的值呢就是entry。
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 }
二、First In, First Out算法
算法是根据先进先出原理来淘汰数据的,实现上是最简单的一种,具体算法如下:
1. 新访问的数据插入FIFO队列尾部,数据在FIFO队列中顺序移动;
2. 淘汰FIFO队列头部的数据;
三、LFU(Least Frequently Used,最不经常使用)
算法根据数据的历史访问频率来淘汰数据,其原理是如果数据过去被访问次数越多,将来被访问的几概率相对比较高。LFU的每个数据块都有一个引用计数,所有数据块按照引用计数排序,具有相同引用计数的数据块则按照时间排序。
具体算法如下:
1. 新加入数据插入到队列尾部(因为引用计数为1);
2. 队列中的数据被访问后,引用计数增加,队列重新排序;
3. 当需要淘汰数据时,将已经排序的列表最后的数据块删除;
评价一个缓存算法好坏的标准主要有两个,一是命中率要高,二是算法要容易实现。当存在热点数据时,LRU的效率很好,但偶发性的、周期性的批量操作会导致LRU命中率急剧下降,缓存污染情况比较严重。LFU效率要优于LRU,且能够避免周期性或者偶发性的操作导致缓存命中率下降的问题。但LFU需要记录数据的历史访问记录,一旦数据访问模式改变,LFU需要更长时间来适用新的访问模式,即:LFU存在历史数据影响将来数据的“缓存污染”效用。FIFO虽然实现很简单,但是命中率很低,实际上也很少使用这种算法。
参考:http://blog.csdn.net/michaellufhl/article/details/6203666
http://blog.csdn.net/beiyetengqing/article/details/7855933
http://my.oschina.net/u/866190/blog/188712