java中cache是什么_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 classEntry {2 Entry prev;//前一节点

3 Entry next;//后一节点

4 Object value;//值

5 Object key;//键

6 }

hashtable里，我们需要保存该entry, 这个时候，我们用entry的键作为hashtable 里的键，而hashtable的值呢就是entry。

1 public classLRUCache {2

3 private intcacheSize;4 private Hashtable nodes;//缓存容器

5 private intcurrentSize;6 private Entry first;//链表头

7 private Entry last;//链表尾

8

9 public LRUCache(inti) {10 currentSize = 0;11 cacheSize =i;12 nodes = new Hashtable(i);//缓存容器

13 }14

15 /**

16 * 获取缓存中对象,并把它放在最前面17 */

18 publicEntry get(Object key) {19 Entry node =nodes.get(key);20 if (node != null) {21 moveToHead(node);22 returnnode;23 } else{24 return null;25 }26 }27

28 /**

29 * 添加 entry到hashtable, 并把entry30 */

31 public voidput(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 = newEntry();44 }45 node.value =value;46 //将最新使用的节点放到链表头，表示最新使用的.

47 moveToHead(node);48 nodes.put(key, node);49 }50

51 /**

52 * 将entry删除, 注意：删除操作只有在cache满了才会被执行53 */

54 public voidremove(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 * 删除链表尾部节点，即使用最后 使用的entry75 */

76 private voidremoveLast() {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 voidmoveToHead(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 voidclear() {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