Caffeine是当前最优秀的内存缓存框架，不论读还是写的效率都远高于其他缓存，而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
void test1() {
Cache<Object, Object> cache = Caffeine.newBuilder()
// 初始数量
.initialCapacity(10)
// 最大条数
.maximumSize(10)
// expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准
// 最后一次写操作后经过指定时间过期
.expireAfterWrite(1, TimeUnit.SECONDS)
// 最后一次读或写操作后经过指定时间过期
.expireAfterAccess(1, TimeUnit.SECONDS)
// 监听缓存被移除
.removalListener((key, value, cause) -> {})
// 记录命中
.recordStats()
.build();
cache.put("1", "张三");
System.out.println(cache.asMap());
System.out.println(cache.getIfPresent("1"));
System.out.println(cache.get("2", o -> "默认值"));
}运行结果
{1=张三}
张三
默认值
@Test
void test2() {
AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
// 创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存：仅支持LoadingCache
.refreshAfterWrite(1, TimeUnit.SECONDS)
.expireAfterWrite(1, TimeUnit.SECONDS)
.expireAfterAccess(1, TimeUnit.SECONDS)
.maximumSize(10)
// 根据key查询数据库里面的值
.buildAsync(key -> {
Thread.sleep(1000);
return new Date().toString();
});
// 异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);
}@Test
void test3() {
LoadingCache<String, String> cache = Caffeine.newBuilder()
// 创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存：refreshAfterWrite仅支持LoadingCache
.refreshAfterWrite(1, TimeUnit.SECONDS)
.expireAfterWrite(1, TimeUnit.SECONDS)
.expireAfterAccess(1, TimeUnit.SECONDS)
.maximumSize(10)
// 开启记录缓存命中率等信息
.recordStats()
// 根据key查询数据库里面的值
.build(key -> {
TimeUnit.MILLISECONDS.sleep(1000);
return new Date().toString();
});
cache.put("1", "小明");
cache.get("1");
/*
* hitCount :命中的次数
* missCount:未命中次数
* requestCount:请求次数
* hitRate:命中率
* missRate:丢失率
* loadSuccessCount:成功加载新值的次数
* loadExceptionCount:失败加载新值的次数
* totalLoadCount:总条数
* loadExceptionRate:失败加载新值的比率
* totalLoadTime:全部加载时间
* evictionCount:丢失的条数
*/
System.out.println(cache.stats());
}会影响性能，生产环境下建议不开启
LRU的优点：LRU相比于LFU而言性能更好一些，因为它算法相对比较简单，不需要记录访问频次，可以更好地应对突发流量；
LRU的缺点：虽然性能好一些，但是它通过历史数据来预测未来是局限的，它会认为最后到来的数据是最可能被再次访问的，从而给与它最高的优先级。有些非热点数据被访问过后，占据了高优先级，它会在缓存中占据相当长的时间，从而造成空间浪费；
LFU的优点：LRU根据访问频次访问，在大部分情况下，热点数据的频次肯定高于非热点数据，所以它的命中率非常高；
LFU的缺点：LFU算法相对比较复杂，性能比LRU差。有问题的是下面这种情况，比如前一段时间微博有个热点话题热度非常高，就比如那种可以让微博短时间停止服务的，于是赶紧缓存起来，LFU算法记录了其中热点词的访问频率，可能高达十几亿，而过后很长一段时间，这个话题已经不是热点了，新的热点也来了，但是，新热点话题的热度没办法到达十几亿，也就是说访问频次没有之前的话提高，那之前的热点就会一直占据着缓存空间，长时间无法被剔除。
3.1 4种淘汰方式与例子
Caffeine有4种缓存淘汰设置
// 缓存大小淘汰
@Test
public void maximumSizeTest() throws InterruptedException {
Cache<Object, Object> cache = Caffeine.newBuilder()
// 超过10个后会使用W-TinyLFU算法进行淘汰
.maximumSize(10)
.build();
for (int i = 1; i <= 10; i++) {
cache.put(i, i);
}
// 缓存淘汰是异步的
TimeUnit.MILLISECONDS.sleep(500);
// 打印还没有被淘汰的缓存
System.out.println(cache.asMap());
}
// 权重淘汰
@Test
public void maximumWeightTest() throws InterruptedException {
Cache<Integer, Integer> cache = Caffeine.newBuilder()
// 限制总权值，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
.maximumWeight(100)
.weigher((Weigher<Integer, Integer>) (key, value) -> key)
.build();
// 总权重其实是=所有缓存的权重加起来
int maximumWeight = 0;
for (int i = 1; i < 20; i++) {
cache.put(i, i);
maximumWeight += i;
System.out.println("i = " + i + ", maximumWeight = " + maximumWeight);
}
System.out.println("总权重 = " + maximumWeight);
// 缓存淘汰是异步的
TimeUnit.MILLISECONDS.sleep(500);
// 打印还没有被淘汰的缓存
System.out.println(cache.asMap());
}
// 访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）
@Test
void expireAfterAccessTest() throws InterruptedException {
Cache<Object, Object> cache = Caffeine.newBuilder()
.expireAfterAccess(1, TimeUnit.SECONDS)
// 可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
// 若不设置scheduler,则缓存会在下一次调用get的时候才会被动删除
.scheduler(Scheduler.systemScheduler())
.build();
cache.put(1, 2);
System.out.println(cache.getIfPresent(1));
Thread.sleep(3000);
System.out.println(cache.getIfPresent(1));
}
// 写入后到期
@Test
void expireAfterWriteTest() throws InterruptedException {
Cache<Object, Object> cache = Caffeine.newBuilder()
.expireAfterWrite(1, TimeUnit.SECONDS)
// 可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
// 若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
.scheduler(Scheduler.systemScheduler())
.build();
cache.put(1, 2);
TimeUnit.MILLISECONDS.sleep(3000);
System.out.println(cache.getIfPresent(1));
}另外还有一个refreshAfterWrite()表示x秒后自动刷新缓存可以配合以上的策略使用
// 另外还有一个refreshAfterWrite()表示x秒后自动刷新缓存可以配合以上的策略使用
private static int num = 0;
@Test
void refreshAfterWriteTest() throws InterruptedException {
LoadingCache<Object, Integer> cache = Caffeine.newBuilder()
.refreshAfterWrite(1, TimeUnit.SECONDS)
.build(integer -> ++num);
// 获取ID=1的值，由于缓存里还没有，所以会自动放入缓存
System.out.println(cache.get(1));
// 延迟2秒后，理论上自动刷新缓存后取到的值是2
// 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
// 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
Thread.sleep(2000);
System.out.println(cache.getIfPresent(1));// 1
//此时才会刷新缓存，而第一次拿到的还是旧值
System.out.println(cache.getIfPresent(1));// 2
}实践1
实践2
缓存的解决方案一般有三种：
