一、LRU
1.1 原理
LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。——访问时间
1.2. 实现
最常见的实现是使用一个链表保存缓存数据,详细算法实现如下:
(1). 新数据插入到链表头部;
(2). 每当缓存命中(即缓存数据被访问),则将数据移到链表头部;
(3). 当链表满的时候,将链表尾部的数据丢弃。
1.3. 分析
【命中率】当存在热点数据时,LRU的效率很好,但偶发性的、周期性的批量操作会导致LRU命中率急剧下降,缓存污染情况比较严重。
【复杂度】实现简单。
【代价】命中时需要遍历链表,找到命中的数据块索引,然后需要将数据移到头部。
1.4 JAVA代码实现
1.4.1 LinkedHashMap实现(继承方式)
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
//最大缓存大小
private final int MAX_CACHE_SIZE;
/**
* 构造函数,当参数accessOrder为true时,即会按照访问顺序排序,最近访问的放在最前,最早访问的放在后面
* @param cacheSize
*/
public LRUCache(int cacheSize) {
super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
MAX_CACHE_SIZE = cacheSize;
}
/**
* LinkedHashMap自带的判断是否删除最老的元素方法,默认返回false,即不删除老数据
* 判断当缓存大小超过最大缓存大小时返回true
*/
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > MAX_CACHE_SIZE;
}
/**
* 测试
*/
public static void main(String[] args) {
LRUCache lruCache = new LRUCache(8);
for (int i = 0; i < 10; i++) {
lruCache.put(i, i);
System.out.println(lruCache);
}
}
}
1.4.2 LinkedHashMap实现(关联方式)
/**
* 使用关联方式实现,由于没有继承map接口,需要自己实现同步接口
*/
public class LRUCache<K, V> {
//最大缓存大小
private final int MAX_CACHE_SIZE;
//默认加载因子
private final float DEFAULT_LOAD_FACTOR = 0.75f;
private LinkedHashMap<K, V> map;
/**
* 构造函数
*/
public LRUCache(int cacheSize) {
MAX_CACHE_SIZE = cacheSize;
//根据cacheSize和加载因子计算hashmap的capactiy,+1确保当达到cacheSize上限时不会触发hashmap的扩容,
int capacity = (int) Math.ceil(MAX_CACHE_SIZE / DEFAULT_LOAD_FACTOR) + 1;
map = new LinkedHashMap(capacity, DEFAULT_LOAD_FACTOR, true) {
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > MAX_CACHE_SIZE;
}
};
}
public synchronized int size() {
return map.size();
}
public synchronized void put(K key, V value) {
map.put(key, value);
}
}
1.4.3 链表+HashMap实现
/**
* 使用链表+HashMap实现,非线程安全,需要自己实现同步接口
*/
public class LRUCache<K, V> {
//最大缓存大小
private final int MAX_CACHE_SIZE;
private Entry first;
private Entry last;
private HashMap<K, Entry<K, V>> hashMap;
/**
* 构造函数
*/
public LRUCache(int cacheSize) {
MAX_CACHE_SIZE = cacheSize;
hashMap = new HashMap<>();
}
/**
* 移除最后的结点
*/
private void removeLast() {
if (last != null) {
last = last.pre;
if (last == null) first = null;
else last.next = null;
}
}
/**
* 把结点移到头结点
*/
private void moveToFirst(Entry entry) {
if (entry == first) return;
if (entry.pre != null) entry.pre.next = entry.next;
if (entry.next != null) entry.next.pre = entry.pre;
if (entry == last) last = last.pre;
if (first == null || last == null) {
first = last = entry;
return;
}
entry.next = first;
first.pre = entry;
first = entry;
entry.pre = null;
}
public void put(K key, V value) {
Entry entry = getEntry(key);
if (entry == null) {
if (hashMap.size() >= MAX_CACHE_SIZE) {
hashMap.remove(last.key);
removeLast();
}
entry = new Entry();
entry.key = key;
}
entry.value = value;
moveToFirst(entry);
hashMap.put(key, entry);
}
private Entry<K, V> getEntry(K key) {
return hashMap.get(key);
}
public V get(K key) {
Entry<K, V> entry = getEntry(key);
if (entry == null) return null;
moveToFirst(entry);
return entry.value;
}
public void remove(K key) {
Entry entry = getEntry(key);
if (entry != null) {
if (entry.pre != null) entry.pre.next = entry.next;
if (entry.next != null) entry.next.pre = entry.pre;
if (entry == first) first = entry.next;
if (entry == last) last = entry.pre;
}
hashMap.remove(key);
}
class Entry<K, V> {
public Entry pre;
public Entry next;
public K key;
public V value;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
Entry entry = first;
while (entry != null) {
sb.append(String.format("%s:%s ", entry.key, entry.value));
entry = entry.next;
}
return sb.toString();
}
public static void main(String[] args) {
LRUCache lruCache = new LRUCache(8);
for (int i = 0; i < 10; i++) {
lruCache.put(i, i);
System.out.println(lruCache);
}
}
}
二、LRU-K
2.1. 原理
LRU-K中的K代表最近使用的次数,因此LRU可以认为是LRU-1。LRU-K的主要目的是为了解决LRU算法“缓存污染”的问题,其核心思想是将“最近使用过1次”的判断标准扩展为“最近使用过K次”。
2.2. 实现
相比LRU,LRU-K需要多维护一个队列,用于记录所有缓存数据被访问的历史。只有当数据的访问次数达到K次的时候,才将数据放入缓存。当需要淘汰数据时,LRU-K会淘汰第K次访问时间距当前时间最大的数据。详细实现如下
`
-
数据第一次被访问,加入到访问历史列表(简称记录表);在记录表中对应的K单元中设置最后访问时间=new(),且设置访问次数为1;
-
如果数据在访问历史列表里后没有达到K次访问,则访问次数+1;
-
当访问历史队列中的数据访问次数达到K次后,将数据索引从历史队列删除,将数据移到缓存队列中,并缓存此数据,缓存队列重新按照时间排序;
-
缓存数据队列中被再次访问后,重新排序;
-
需要淘汰数据时,淘汰缓存队列中排在末尾的数据,即:淘汰“倒数第K次访问离现在最久”的数据。
LRU-K具有LRU的优点,同时能够避免LRU的缺点,实际应用中LRU-2是综合各种因素后最优的选择,LRU-3或者更大的K值命中率会高,但适应性差,需要大量的数据访问才能将历史访问记录清除掉。 `
2.3. 分析
【命中率】 LRU-K降低了“缓存污染”带来的问题,命中率比LRU要高。
【复杂度】 LRU-K队列是一个优先级队列,算法复杂度和代价比较高。
【代价】 由于LRU-K还需要记录那些被访问过、但还没有放入缓存的对象,因此内存消耗会比LRU要多;当数据量很大的时候,内存消耗会比较可观。 LRU-K需要基于时间进行排序(可以需要淘汰时再排序,也可以即时排序),CPU消耗比LRU要高。
2.4 数据缓存框架实现
系统数据存储组成 数据存储使用DB+本地缓存(LocalCache)+Redis三层结构,如下图:
数据查询流程 先从本地缓存取,本地缓存没有从redis取(同时更新本地缓存),redis没有从DB取(同时更新Redis)。具体步骤如下图:
1)先计算该数据获取总次数
2)未达到K访问记录时直接从redis取数据
3)达到K次访问记录时,从本地缓存取,本地缓存不存在时从redis获取数据(同时放入本地缓存中)
三、Two queues(2Q)
3.1. 原理
Two queues(以下使用2Q代替)算法类似于LRU-2,不同点在于2Q将LRU-2算法中的访问历史队列(注意这不是缓存数据的)改为一个FIFO缓存队列,即:2Q算法有两个缓存队列,一个是FIFO队列,一个是LRU队列。
3.2. 实现
当数据第一次访问时,2Q算法将数据缓存在FIFO队列里面,当数据第二次被访问时,则将数据从FIFO队列移到LRU队列里面,两个队列各自按照自己的方法淘汰数据。详细实现如下:
1. 新访问的数据插入到FIFO队列;
2. 如果数据在FIFO队列中一直没有被再次访问,则最终按照FIFO规则淘汰;
3. 如果数据在FIFO队列中被再次访问,则将数据移到LRU队列头部;
4. 如果数据在LRU队列再次被访问,则将数据移到LRU队列头部;
5. LRU队列淘汰末尾的数据。
3.3. 分析
【命中率】 2Q算法的命中率要高于LRU。
【复杂度】 需要两个队列,但两个队列本身都比较简单。
【代价】 FIFO和LRU的代价之和。
2Q算法和LRU-2算法命中率类似,内存消耗也比较接近,但对于最后缓存的数据来说,2Q会减少一次从原始存储读取数据或者计算数据的操作。