详细介绍高性能Java缓存库Caffeine
1、介绍
在本文中，我们来看看caffeine — 一个高性能的 java 缓存库。
缓存和 map 之间的一个根本区别在于缓存可以回收存储的 item。
回收策略为在指定时间删除哪些对象。此策略直接影响缓存的命中率 — 缓存库的一个重要特征。
caffeine 因使用 window tinylfu 回收策略，提供了一个近乎最佳的命中率。
2、依赖
我们需要在 pom.xml 中添加 caffeine 依赖：
<dependency> <groupid>com.github.ben-manes.caffeine</groupid> <artifactid>caffeine</artifactid> <version>2.5.5</version> </dependency>
您可以在maven central 上找到最新版本的 caffeine。
3、填充缓存
让我们来了解一下 caffeine 的三种缓存填充策略：手动、同步加载和异步加载。
首先，我们为要缓存中存储的值类型写一个类：
class dataobject {
private final string data;
private static int objectcounter = 0;
// standard constructors/getters
public static dataobject get(string data) {
objectcounter++;
return new dataobject(data);
}
}
3.1、手动填充
在此策略中，我们手动将值放入缓存之后再检索。
让我们初始化缓存：
cache<string, dataobject> cache = caffeine.newbuilder() .expireafterwrite(1, timeunit.minutes) .maximumsize(100) .build();
现在，我们可以使用 getifpresent 方法从缓存中获取一些值。 如果缓存中不存在此值，则此方法将返回 null：
string key = "a"; dataobject dataobject = cache.getifpresent(key); assertnull(dataobject);
我们可以使用 put 方法手动填充缓存：
cache.put(key, dataobject); dataobject = cache.getifpresent(key); assertnotnull(dataobject);
我们也可以使用 get 方法获取值，该方法将一个参数为 key 的 function 作为参数传入。如果缓存中不存在该键，则该函数将用于提供回退值，该值在计算后插入缓存中：
dataobject = cache
.get(key, k -> dataobject.get("data for a"));
assertnotnull(dataobject);
assertequals("data for a", dataobject.getdata());
get 方法可以原子方式执行计算。这意味着您只进行一次计算 — 即使多个线程同时请求该值。这就是为什么使用 get 优于 getifpresent。
有时我们需要手动使一些缓存的值失效：
cache.invalidate(key); dataobject = cache.getifpresent(key); assertnull(dataobject);
3.2、同步加载
这种加载缓存的方法使用了与用于初始化值的 function 相似的手动策略的 get 方法。让我们看看如何使用它。
首先，我们需要初始化缓存：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.maximumsize(100)
.expireafterwrite(1, timeunit.minutes)
.build(k -> dataobject.get("data for " + k));
现在我们可以使用 get 方法检索值：
dataobject dataobject = cache.get(key);
assertnotnull(dataobject);
assertequals("data for " + key, dataobject.getdata());
我们也可以使用 getall 方法获取一组值：
map<string, dataobject> dataobjectmap
= cache.getall(arrays.aslist("a", "b", "c"));
assertequals(3, dataobjectmap.size());
从传递给 build 方法的底层后端初始化函数检索值。 这使得可以使用缓存作为访问值的主要门面（facade）。
3.3、异步加载
此策略的作用与之前相同，但是以异步方式执行操作，并返回一个包含值的 completablefuture：
asyncloadingcache<string, dataobject> cache = caffeine.newbuilder()
.maximumsize(100)
.expireafterwrite(1, timeunit.minutes)
.buildasync(k -> dataobject.get("data for " + k));
我们可以以相同的方式使用 get 和 getall 方法，同时考虑到他们返回的是 completablefuture：
string key = "a";
cache.get(key).thenaccept(dataobject -> {
assertnotnull(dataobject);
assertequals("data for " + key, dataobject.getdata());
});
cache.getall(arrays.aslist("a", "b", "c"))
.thenaccept(dataobjectmap -> assertequals(3, dataobjectmap.size()));
completablefuture 有许多有用的 api，您可以在中获取更多内容。
4、值回收
caffeine 有三个值回收策略：基于大小，基于时间和参考。
4.1、基于大小回收
这种回收方式假定当超过配置的缓存大小限制时会发生回收。 获取大小有两种方法：缓存中计数对象，或获取权重。
让我们看看如何计算缓存中的对象。当缓存初始化时，其大小等于零：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.maximumsize(1)
.build(k -> dataobject.get("data for " + k));
assertequals(0, cache.estimatedsize());
当我们添加一个值时，大小明显增加：
cache.get("a");
assertequals(1, cache.estimatedsize());
我们可以将第二个值添加到缓存中，这导致第一个值被删除：
cache.get("b");
cache.cleanup();
assertequals(1, cache.estimatedsize());
值得一提的是，在获取缓存大小之前，我们调用了 cleanup 方法。 这是因为缓存回收被异步执行，这种方法有助于等待回收的完成。
我们还可以传递一个 weigher function 来获取缓存的大小：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.maximumweight(10)
.weigher((k,v) -> 5)
.build(k -> dataobject.get("data for " + k));
assertequals(0, cache.estimatedsize());
cache.get("a");
assertequals(1, cache.estimatedsize());
cache.get("b");
assertequals(2, cache.estimatedsize());
当 weight 超过 10 时，值将从缓存中删除：
cache.get("c");
cache.cleanup();
assertequals(2, cache.estimatedsize());
4.2、基于时间回收
这种回收策略是基于条目的到期时间，有三种类型：
- 访问后到期 — 从上次读或写发生后，条目即过期。
- 写入后到期 — 从上次写入发生之后，条目即过期
- 自定义策略 — 到期时间由 expiry 实现独自计算
让我们使用 expireafteraccess 方法配置访问后过期策略：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.expireafteraccess(5, timeunit.minutes)
.build(k -> dataobject.get("data for " + k));
要配置写入后到期策略，我们使用 expireafterwrite 方法：
cache = caffeine.newbuilder()
.expireafterwrite(10, timeunit.seconds)
.weakkeys()
.weakvalues()
.build(k -> dataobject.get("data for " + k));
要初始化自定义策略，我们需要实现 expiry 接口：
cache = caffeine.newbuilder().expireafter(new expiry<string, dataobject>() {
@override
public long expireaftercreate(
string key, dataobject value, long currenttime) {
return value.getdata().length() * 1000;
}
@override
public long expireafterupdate(
string key, dataobject value, long currenttime, long currentduration) {
return currentduration;
}
@override
public long expireafterread(
string key, dataobject value, long currenttime, long currentduration) {
return currentduration;
}
}).build(k -> dataobject.get("data for " + k));
4.3、基于引用回收
我们可以将缓存配置为启用缓存键值的垃圾回收。为此，我们将 key 和 value 配置为 弱引用，并且我们可以仅配置软引用以进行垃圾回收。
当没有任何对对象的强引用时，使用 weakrefence 可以启用对象的垃圾收回收。softreference 允许对象根据 jvm 的全局最近最少使用（least-recently-used）的策略进行垃圾回收。有关 java 引用的更多详细信息，请参见。
我们应该使用 caffeine.weakkeys()、caffeine.weakvalues() 和 caffeine.softvalues() 来启用每个选项：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.expireafterwrite(10, timeunit.seconds)
.weakkeys()
.weakvalues()
.build(k -> dataobject.get("data for " + k));
cache = caffeine.newbuilder()
.expireafterwrite(10, timeunit.seconds)
.softvalues()
.build(k -> dataobject.get("data for " + k));
5、刷新
可以将缓存配置为在定义的时间段后自动刷新条目。让我们看看如何使用 refreshafterwrite 方法：
caffeine.newbuilder()
.refreshafterwrite(1, timeunit.minutes)
.build(k -> dataobject.get("data for " + k));
这里我们应该要明白 expireafter 和 refreshafter 之间的区别。 当请求过期条目时，执行将发生阻塞，直到 build function 计算出新值为止。
但是，如果条目可以刷新，则缓存将返回一个旧值，并异步重新加载该值。
6、统计
caffeine 有一种记录缓存使用情况的统计方式：
loadingcache<string, dataobject> cache = caffeine.newbuilder()
.maximumsize(100)
.recordstats()
.build(k -> dataobject.get("data for " + k));
cache.get("a");
cache.get("a");
assertequals(1, cache.stats().hitcount());
assertequals(1, cache.stats().misscount());
我们也可能会传入 recordstats supplier，创建一个 statscounter 的实现。每次与统计相关的更改将推送此对象。
7、结论
在本文中，我们熟悉了 java 的 caffeine 缓存库。 我们看到了如何配置和填充缓存，以及如何根据我们的需要选择适当的到期或刷新策略。
文中示例的源代码可以在 github 上找到。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。