本地缓存Caffeine

Caffeine

说起Guava Cache,很多人都不会陌生,它是Google Guava工具包中的一个非常方便易用的本地化缓存实现,基于LRU算法实现,支持多种缓存过期策略。由于Guava的大量使用,Guava Cache也得到了大量的应用。但是,Guava Cache的性能一定是最好的吗?也许,曾经,它的性能是非常不错的。但所谓长江后浪推前浪,总会有更加优秀的技术出现。今天,我就来介绍一个比Guava Cache性能更高的缓存框架:Caffeine。

Tips: Spring5(SpringBoot2)开始用Caffeine取代guava.详见官方信息SPR-13797
https://jira.spring.io/browse/SPR-13797

什么时候用

  1. 愿意消耗一些内存空间来提升速度
  2. 预料到某些键会被多次查询
  3. 缓存中存放的数据总量不会超出内存容量

性能

由图可以看出,Caffeine不论读还是写的效率都远高于其他缓存。

这里只列出部分性能比较,详细请看官方官方 https://github.com/ben-manes/caffeine/wiki/Benchmarks

依赖

我们需要在 pom.xml 中添加 caffeine 依赖:

版本问题参考https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine

1<dependency> 2 <groupId>com.github.ben-manes.caffeine</groupId> 3 <artifactId>caffeine</artifactId> 4 <version>2.7.0</version> 5</dependency> 6 7

新建对象

1// 1、最简单 2Cache<String, Object> cache = Caffeine.newBuilder() 3 .build(); 4// 2、真实使用过程中我们需要自己配置参数。这里只列举部分,具体请看下面列表 5Cache<String, Object> cache = Caffeine.newBuilder() 6 .initialCapacity(2)//初始大小 7 .maximumSize(2)//最大数量 8 .expireAfterWrite(3, TimeUnit.SECONDS)//过期时间 9 .build(); 10 11

参数含义

  • initialCapacity: 初始的缓存空间大小
  • maximumSize: 缓存的最大数量
  • maximumWeight: 缓存的最大权重
  • expireAfterAccess: 最后一次读或写操作后经过指定时间过期
  • expireAfterWrite: 最后一次写操作后经过指定时间过期
  • refreshAfterWrite: 创建缓存或者最近一次更新缓存后经过指定时间间隔,刷新缓存
  • weakKeys: 打开key的弱引用
  • weakValues:打开value的弱引用
  • softValues:打开value的软引用
  • recordStats:开发统计功能

添加数据

Caffeine 为我们提供了三种填充策略:

手动、同步和异步

手动添加

很简单的

1public static void main(String[] args) { 2 Cache<String, String> cache = Caffeine.newBuilder() 3 .build(); 4 cache.put("hello", "world"); 5 System.out.println(cache.getIfPresent("hello")); 6} 7 8

自动添加1(自定义添加函数)

1Cache<String, String> cache = Caffeine.newBuilder() 2 .build(); 3 4// 1.如果缓存中能查到,则直接返回 5// 2.如果查不到,则从我们自定义的getValue方法获取数据,并加入到缓存中 6cache.get("hello", new Function<String, String>() { 7 @Override 8 public String apply(String k) { 9 return getValue(k); 10 } 11}); 12System.out.println(cache.getIfPresent("hello")); 13} 14 15// 缓存中找不到,则会进入这个方法。一般是从数据库获取内容 16private static String getValue(String k) { 17 return k + ":value"; 18 19

// 这种写法可以简化成下面Lambda表达式
cache.get(“hello”, new Function<String, String>() {
@Override
public String apply(String k) {
return getValue(k);
}
});
// 可以简写为
cache.get(“hello”, k -> getValue(k));

自动添加2(初始添加)

和上面方法一样,只不过这个是在新建对象的时候添加

1LoadingCache<String, String> loadingCache = Caffeine.newBuilder() 2 .build(new CacheLoader<String, String>() { 3 @Override 4 public String load(String k) { 5 return getValue(k); 6 } 7 }); 8// 同样可简化为下面这样 9LoadingCache<String, String> loadingCache2 = Caffeine.newBuilder() 10 .build(k -> getValue(k)); 11 12

过期策略

Caffeine提供三类驱逐策略:

  1. 基于大小(size-based)
  2. 基于时间(time-based)
  3. 基于引用(reference-based)

1、大小

1Cache<String, String> cache = Caffeine.newBuilder() 2 .maximumSize(3) 3 .build(); 4cache.put("key1", "value1"); 5cache.put("key2", "value2"); 6cache.put("key3", "value3"); 7cache.put("key4", "value4"); 8cache.put("key5", "value5"); 9cache.cleanUp(); 10System.out.println(cache.getIfPresent("key1")); 11System.out.println(cache.getIfPresent("key2")); 12System.out.println(cache.getIfPresent("key3")); 13System.out.println(cache.getIfPresent("key4")); 14System.out.println(cache.getIfPresent("key5")); 15 16

输出结果

1null 2value2 3null 4value4 5value5 6 7

1、淘汰2个

2、淘汰并不是按照先后顺序,内部有自己的算法

2、时间

Caffeine提供了三种定时驱逐策略:

  • expireAfterAccess(long, TimeUnit):在最后一次访问或者写入后开始计时,在指定的时间后过期。假如一直有请求访问该key,那么这个缓存将一直不会过期。
  • expireAfterWrite(long, TimeUnit): 在最后一次写入缓存后开始计时,在指定的时间后过期。
  • expireAfter(Expiry): 自定义策略,过期时间由Expiry实现独自计算。

缓存的删除策略使用的是惰性删除和定时删除。这两个删除策略的时间复杂度都是O(1)。

expireAfterWrite

1Cache<String, String> cache = Caffeine.newBuilder() 2 .expireAfterWrite(3, TimeUnit.SECONDS) 3 .build(); 4cache.put("key1", "value1"); 5cache.put("key2", "value2"); 6cache.put("key3", "value3"); 7cache.put("key4", "value4"); 8cache.put("key5", "value5"); 9System.out.println(cache.getIfPresent("key1")); 10System.out.println(cache.getIfPresent("key2")); 11Thread.sleep(3*1000); 12System.out.println(cache.getIfPresent("key3")); 13System.out.println(cache.getIfPresent("key4")); 14System.out.println(cache.getIfPresent("key5")); 15 16

结果

1value1 2value2 3null 4null 5null 6 7

例子2

1Cache<String, String> cache = Caffeine.newBuilder() 2 .expireAfterWrite(3, TimeUnit.SECONDS) 3 .build(); 4cache.put("key1", "value1"); 5Thread.sleep(1*1000); 6System.out.println(cache.getIfPresent("key1")); 7Thread.sleep(1*1000); 8System.out.println(cache.getIfPresent("key1")); 9Thread.sleep(1*1000); 10System.out.println(cache.getIfPresent("key1")); 11 12

结果

1value1 2value1 3null 4 5

expireAfterAccess

Access就是读和写

1Cache<String, String> cache = Caffeine.newBuilder() 2 .expireAfterAccess(3, TimeUnit.SECONDS) 3 .build(); 4cache.put("key1", "value1"); 5Thread.sleep(1*1000); 6System.out.println(cache.getIfPresent("key1")); 7Thread.sleep(1*1000); 8System.out.println(cache.getIfPresent("key1")); 9Thread.sleep(1*1000); 10System.out.println(cache.getIfPresent("key1")); 11Thread.sleep(3*1000); 12System.out.println(cache.getIfPresent("key1")); 13 14

结果

1value1 2value1 3value1 4null 5 6

读和写都没有的情况下,3秒后才过期

expireAfter 和 refreshAfter 之间的区别

  • expireAfter 条件触发后,新的值更新完成前,所有请求都会被阻塞,更新完成后其他请求才能访问这个值。这样能确保获取到的都是最新的值,但是有性能损失。
  • refreshAfter 条件触发后,新的值更新完成前也可以访问,不会被阻塞,只是获取的是旧的数据。更新结束后,获取的才是新的数据。有可能获取到脏数据。

3、引用

  • Caffeine.weakKeys() 使用弱引用存储key。如果没有其他地方对该key有强引用,那么该缓存就会被垃圾回收器回收。

  • Caffeine.weakValues() 使用弱引用存储value。如果没有其他地方对该value有强引用,那么该缓存就会被垃圾回收器回收。

  • Caffeine.softValues() 使用软引用存储value。

1Cache<String, Object> cache = Caffeine.newBuilder() 2 .weakValues() 3 .build(); 4Object value1 = new Object(); 5Object value2 = new Object(); 6cache.put("key1", value1); 7cache.put("key2", value2); 8 9value2 = new Object(); // 原对象不再有强引用 10System.gc(); 11System.out.println(cache.getIfPresent("key1")); 12System.out.println(cache.getIfPresent("key2")); 13 14

结果

1java.lang.Object@7a4f0f29 2null 3 4

解释:当给value2引用赋值一个新的对象之后,就不再有任何一个强引用指向原对象。System.gc()触发垃圾回收后,原对象就被清除了。

简单回顾下Java中的四种引用

Java4种引用的级别由高到低依次为:强引用 > 软引用 > 弱引用 > 虚引用

强引用 从来不会 对象的一般状态 JVM停止运行时终止 软引用 在内存不足时 对象缓存 内存不足时终止 弱引用 在垃圾回收时 对象缓存 GC运行后终止 虚引用 Unknown Unknown Unknown

显式删除缓存

除了通过上面的缓存淘汰策略删除缓存,我们还可以手动的删除

1// 1、指定key删除 2cache.invalidate("key1"); 3// 2、批量指定key删除 4List<String> list = new ArrayList<>(); 5list.add("key1"); 6list.add("key2"); 7cache.invalidateAll(list);//批量清除list中全部key对应的记录 8// 3、删除全部 9cache.invalidateAll(); 10 11

淘汰、移除监听器

可以为缓存对象添加一个移除监听器,这样当有记录被删除时可以感知到这个事件。

1Cache<String, String> cache = Caffeine.newBuilder() 2 .expireAfterAccess(3, TimeUnit.SECONDS) 3 .removalListener(new RemovalListener<Object, Object>() { 4 @Override 5 public void onRemoval(@Nullable Object key, @Nullable Object value, @NonNull RemovalCause cause) { 6 System.out.println("key:" + key + ",value:" + value + ",删除原因:" + cause); 7 } 8 }) 9 .expireAfterWrite(1, TimeUnit.SECONDS) 10 .build(); 11cache.put("key1", "value1"); 12cache.put("key2", "value2"); 13cache.invalidate("key1"); 14Thread.sleep(2 * 1000); 15cache.cleanUp(); 16 17

结果

1key:key1,value:value1,删除原因:EXPLICIT 2key:key2,value:value2,删除原因:EXPIRED 3 4

统计

1Cache<String, String> cache = Caffeine.newBuilder() 2 .maximumSize(3) 3 .recordStats() 4 .build(); 5cache.put("key1", "value1"); 6cache.put("key2", "value2"); 7cache.put("key3", "value3"); 8cache.put("key4", "value4"); 9 10cache.getIfPresent("key1"); 11cache.getIfPresent("key2"); 12cache.getIfPresent("key3"); 13cache.getIfPresent("key4"); 14cache.getIfPresent("key5"); 15cache.getIfPresent("key6"); 16System.out.println(cache.stats()); 17 18

结果

1CacheStats{hitCount=4, missCount=2, loadSuccessCount=0, loadFailureCount=0, totalLoadTime=0, evictionCount=0, evictionWeight=0} 2 3

除了结果输出的内容,CacheStats还可以获取如下数据。

上一篇:spring cache

代码交流 2021