GuavaCache学习笔记一：自定义LRU算法的缓存实现

前言

今天在看GuavaCache缓存相关的源码，这里想到先自己手动实现一个LRU算法。于是乎便想到LinkedHashMap和LinkedList+HashMap, 这里仅仅是作为简单的复习一下。

LRU

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

代码实现原理

LinkedList + HashMap： LinkedList其实是一个双向链表，我们可以通过get和put来设置最近请求key的位置，然后hashMap去存储数据
LinkedHashMap：LinkedHashMap是继承自HashMap，只不过Map中的Node节点改为了双向节点，双向节点可以维护添加的顺序，在LinkedHashMap的构造函数中有一个accessOrder，当设置为true后，put和get会自动维护最近请求的位置到last。

LinkedList+HashMap代码实现

LRUCache接口：

/**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:49
 */
public class LinkedListLRUTest {
    public static void main(String[] args) { LRUCache<String, String> cache = new LinkedListLRUCache<>(3); cache.put("1", "1"); cache.put("2", "2"); cache.put("3", "3"); System.out.println(cache); cache.put("4", "4"); System.out.println(cache); System.out.println(cache.get("2")); System.out.println(cache); } }

LinkedList实现：

/**
 * @Description:使用LinkedList+HashMap来实现LRU算法
 * @Author: wangmeng
 * @Date: 2018/12/8-10:41
 */
public class LinkedListLRUCache<K, V> implements LRUCache<K, V> { private final int limit; private final LinkedList<K> keys = new LinkedList<>(); private final Map<K, V> cache = Maps.newHashMap(); public LinkedListLRUCache(int limit) { this.limit = limit; } @Override public void put(K key, V value) { Preconditions.checkNotNull(key); Preconditions.checkNotNull(value); if (keys.size() >= limit) { K oldesKey = keys.removeFirst(); cache.remove(oldesKey); } keys.addLast(key); cache.put(key, value); } @Override public V get(K key) { boolean exist = keys.remove(key); if (!exist) { return null; } keys.addLast(key); return cache.get(key); } @Override public void remove(K key) { boolean exist = keys.remove(key); if (exist) { keys.remove(key); cache.remove(key); } } @Override public int size() { return keys.size(); } @Override public void clear() { keys.clear(); cache.clear(); } @Override public int limit() { return this.limit; } @Override public String toString() { StringBuilder builder = new StringBuilder(); for (K key : keys) { builder.append(key).append("=").append(cache.get(key)).append(";"); } return builder.toString(); } }

LinkedList测试类：

/**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:49
 */
public class LinkedListLRUTest {
    public static void main(String[] args) { LRUCache<String, String> cache = new LinkedListLRUCache<>(3); cache.put("1", "1"); cache.put("2", "2"); cache.put("3", "3"); System.out.println(cache); cache.put("4", "4"); System.out.println(cache); System.out.println(cache.get("2")); System.out.println(cache); } }

LinkedList测试类返回值：

1=1;2=2;3=3;
2=2;3=3;4=4;
2
3=3;4=4;2=2;

LinkedHashMap实现

/**
 * @Description: 不是一个线程安全的类，这里是使用LinkedHashMap来做LRU算法
 * @Author: wangmeng
 * @Date: 2018/12/8-10:14
 */
public class LinkedHashLRUCache<K, V> implements LRUCache<K, V> { private static class InternalLRUCache<K, V> extends LinkedHashMap<K, V> { final private int limit; private InternalLRUCache(int limit) { super(16, 0.75f, true); this.limit = limit ; } //实现remove元素的方法，这个是重写了LinkedHashMap中的方法。因为在HashMap的putVal会调用afterNodeInsertion(), 而这个方法会判断removeEldestEntry方法。 @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > limit; } } private final int limit; //使用组合关系优于继承，这里只对外暴漏LRUCache中的方法 private final InternalLRUCache<K, V> internalLRUCache; public LinkedHashLRUCache(int limit) { Preconditions.checkArgument(limit > 0, "The limit big than zero."); this.limit = limit; this.internalLRUCache = new InternalLRUCache(limit); } @Override public void put(K key, V value) { this.internalLRUCache.put(key, value); } @Override public V get(K key) { return this.internalLRUCache.get(key); } @Override public void remove(K key) { this.internalLRUCache.remove(key); } @Override public int size() { return this.internalLRUCache.size(); } @Override public void clear() { this.internalLRUCache.clear(); } @Override public int limit() { return this.limit; } @Override public String toString() { return internalLRUCache.toString(); } }

LinkedHashMap测试类：

/**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:30
 */
public class LinkedHashLRUTest {
    public static void main(String[] args) { LRUCache<String, String> cache = new LinkedHashLRUCache<>(3); cache.put("1", "1"); cache.put("2", "2"); cache.put("3", "3"); System.out.println(cache); cache.put("4", "4"); System.out.println(cache); System.out.println(cache.get("2")); System.out.println(cache); } }

LinkedHashMap测试结果：

{1=1, 2=2, 3=3}
{2=2, 3=3, 4=4} 2 {3=3, 4=4, 2=2}

文章目录
简介
实现LRU
LinkedHashMap中LRU算法实现
简介
LRU全称是Least Recently Used，即最近最久未使用的意思。

LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。

实现LRU
1.用一个数组来存储数据，给每一个数据项标记一个访问时间戳，每次插入新数据项的时候，先把数组中存在的数据项的时间戳自增，并将新数据项的时间戳置为0并插入到数组中。每次访问数组中的数据项的时候，将被访问的数据项的时间戳置为0。当数组空间已满时，将时间戳最大的数据项淘汰。

2.利用一个链表来实现，每次新插入数据的时候将新数据插到链表的头部；每次缓存命中（即数据被访问），则将数据移到链表头部；那么当链表满的时候，就将链表尾部的数据丢弃。

3.利用链表和hashmap。当需要插入新的数据项的时候，如果新数据项在链表中存在（一般称为命中），则把该节点移到链表头部，如果不存在，则新建一个节点，放到链表头部，若缓存满了，则把链表最后一个节点删除即可。在访问数据的时候，如果数据项在链表中存在，则把该节点移到链表头部，否则返回-1。这样一来在链表尾部的节点就是最近最久未访问的数据项。

对于第一种方法，需要不停地维护数据项的访问时间戳，另外，在插入数据、删除数据以及访问数据时，时间复杂度都是O(n)。对于第二种方法，链表在定位数据的时候时间复杂度为O(n)。所以在一般使用第三种方式来是实现LRU算法。

LinkedHashMap中LRU算法实现
/**
* @Author: Kingcym
* @Description: 非线程安全
* @Date: 2018/11/11 19:09
*/
public class LinkedHashLRUcache<k, v> {
/**
* LinkedHashMap（自身实现了ＬＲＵ算法）
* 1.有序
* 2.每次访问一个元素，都会提到最后面去
*/
private static class InternalLRUcache<k, v> extends LinkedHashMap<k, v> {
private final int limit;

private InternalLRUcache(int limit) {
super(16, 0.75f, true);
this.limit = limit;
}

//是否删除最老的数据
@Override
protected boolean removeEldestEntry(Map.Entry<k, v> eldest) {
return size() > limit;
}
}

private final int limit;
private final InternalLRUcache<k, v> internalLRUcache;

public LinkedHashLRUcache(int limit) {
Assert.state(limit > 0, "limit必须大于0");
this.limit = limit;
this.internalLRUcache = new InternalLRUcache(limit);
}

public void put(k key, v value) {
this.internalLRUcache.put(key, value);
}

public v get(k key) {
return this.internalLRUcache.get(key);
}

public void remove(k key) {
this.internalLRUcache.remove(key);
}

public int size() {
return this.internalLRUcache.size();
}

public void clear() {
this.internalLRUcache.clear();
}

public String toString() {
return internalLRUcache.toString();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较严重。

参考： GuavaCache学习笔记一：自定义LRU算法的缓存实现

参考： Guava---缓存之LRU算法

前言