使用场景
在Java
应用中,对于访问频率高,更新少的数据,通常的方案是将这类数据加入缓存中。相对从数据库中读取来说,读缓存效率会有很大提升。
在集群环境下,常用的分布式缓存有Redis
、Memcached
等。但在某些业务场景上,可能不需要去搭建一套复杂的分布式缓存系统,在单机环境下,通常是会希望使用内部的缓存(LocalCache
)。
实现
这里提供了两种LocalCache
的实现,一种是基于ConcurrentHashMap
实现基本本地缓存,另外一种是基于LinkedHashMap
实现LRU
策略的本地缓存。
基于ConcurrentHashMap的实现
static {
timer = new Timer();
map = new ConcurrentHashMap<>();
}
以ConcurrentHashMap
作为缓存的存储结构。因为ConcurrentHashMap
的线程安全的,所以基于此实现的LocalCache
在多线程并发环境的操作是安全的。在JDK1.8
中,ConcurrentHashMap
是支持完全并发读,这对本地缓存的效率也是一种提升。通过调用ConcurrentHashMap
对map
的操作来实现对缓存的操作。
私有构造函数
private LocalCache() {
}
LocalCache
是工具类,通过私有构造函数强化不可实例化的能力。
缓存清除机制
/**
* 清除缓存任务类
*/
static class CleanWorkerTask extends TimerTask {
private String key;
public CleanWorkerTask(String key) {
this.key = key;
}
public void run() {
LocalCache.remove(key);
}
}
清理失效缓存是由Timer
类实现的。内部类CleanWorkerTask
继承于TimerTask
用户清除缓存。每当新增一个元素的时候,都会调用timer.schedule
加载清除缓存的任务。
基于LinkedHashMap的实现
以LinkedHashMap
作为缓存的存储结构。主要是通过LinkedHashMap
的按照访问顺序的特性来实现LRU
策略。
LRU
LRU
是Least Recently Used
的缩写,即最近最久未使用。LRU
缓存将会利用这个算法来淘汰缓存中老的数据元素,从而优化内存空间。
基于LRU策略的map
这里利用LinkedHashMap
来实现基于LRU
策略的map
。通过调用父类LinkedHashMap
的构造函数来实例化map
。参数accessOrder
设置为true
保证其可以实现LRU
策略。
static class LRUMap<K, V> extends LinkedHashMap<K, V> {
... // 省略部分代码
public LRUMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor, true);
}
... // 省略部分代码
/**
* 重写LinkedHashMap中removeEldestEntry方法;
* 新增元素的时候,会判断当前map大小是否超过DEFAULT_MAX_CAPACITY,超过则移除map中最老的节点;
*
* @param eldest
* @return
*/
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > DEFAULT_MAX_CAPACITY;
}
}
线程安全
/**
* 读写锁
*/
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private final Lock rLock = readWriteLock.readLock();
private final Lock wLock = readWriteLock.writeLock();
LinkedHashMap
并不是线程安全,如果不加控制的在多线程环境下使用的话,会有问题。所以在LRUMap
中引入了ReentrantReadWriteLock
读写锁,来控制并发问题。
缓存淘汰机制
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > DEFAULT_MAX_CAPACITY;
}
此处重写LinkedHashMap
中removeEldestEntry
方法, 当缓存新增元素的时候,会判断当前map
大小是否超过DEFAULT_MAX_CAPACITY
,超过则移除map中最老的节点。
缓存清除机制
缓存清除机制与ConcurrentHashMap
的实现一致,均是通过timer
实现。
作者:特立独行的猪手
链接:https://www.jianshu.com/p/4194483127fe
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
---------------------------------------------------------------------------------------------------------------------------
LRU原理:
LRU一般采用链表的放缓死实现,便于快速移动数据位置。网上找了一个图,感觉画的很赞,所以就粘过来了,为了说明问题~~~~~感谢这个图的作者!!!!
LRU的实现有两种方式:缓存命中后,是否要这个数据缓存项到LRU队列的最前端。
首先这个图说明的是LRU的一种实现方式,那就是在缓存访问命中后,要将这个数据缓存项到达LRU队列的最前端。第五步,将E插入缓存池后,这个缓存池已经满了,所以第六步插入F后,要考虑把近期没有访问的数据,也就是A给淘汰掉了(可怜的A啊。。。。)第七步,C被访问,从时间点来说,C最近被访问过了,所以移动到了链表的头部(暂时没有被淘汰);第八步,将G存入缓存后,G位于链表头部,那么B只能被淘汰了。。。。
因为链表的插入和删除时间复杂度都为O(1),所以用链表不用数组。。。。。(这句是参考别人的,还不是很懂,让我研究研究。。。)
还有数据缓存项不移动到LRU最前端的方式,由下面的例题来详细说明。
下面贴一个例题:
—————————————————————————————————————————————————————————————————————————————
解:
本题是有两种解答的。
1.缓存命中后,这个数据缓存项不要移动到链表最前端:
命中不调整缓存项内容快照如下:
1. 1
2. 5 1
3. 5 1
4. 3 5 1
5. 3 5 1
6. 2 3 5 1
7. 4 2 3 5(淘汰1)
8. 1 4 2 3 (淘汰5)
9 1 4 2 3(命中2
到达第6步时,缓存池已经满了,所以开始淘汰,淘汰两次,最后淘汰5
2.缓存命中后,这个数据缓存项要移动到链表最前端
1. 1
2. 5 1
3. 1 5
4. 3 1 5
5 .5 3 1
6. 2 5 3 1
7. 4 2 5 3(淘汰1)
8. 1 4 2 5(淘汰3)
9 .2 1 4 5
淘汰2次,最后淘汰3