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虽然实现很简单，但是命中率很低，实际上也很少使用这种算法。
