java 本地缓存框架_Java本地缓存框架系列-Caffeine-1. 简介与使用

Caffeine 是一个基于Java 8的高性能本地缓存框架，其结构和 Guava Cache 基本一样，api也一样，基本上很容易就能替换。 Caffeine 实际上就是在 Guava Cache 的基础上，利用了一些 Java 8 的新特性，提高了某些场景下的性能效率。

这一章节我们会从 Caffeine 的使用引入，并提出一些问题，之后分析其源代码解决这些问题来让我们更好的去了解 Caffeine 的原理，更好的使用与优化，并且会对于我们之后的编码有所裨益。

我们来看一下 Caffeine 的基本使用，首先是创建：

限制缓存大小

Caffeine 有两种方式限制缓存大小。两种配置互斥，不能同时配置

1. 创建一个限制容量 Cache

Cache cache = Caffeine

.newBuilder()

//设置缓存的 Entries 个数最多不超过1000个

.maximumSize(1000)

.build();

需要注意的是，实际实现上为了性能考虑，这个限制并不会很死板：在缓存元素个数快要达到最大限制的时候，过期策略就开始执行了，所以在达到最大容量前也许某些不太可能再次访问的 Entry 就被过期掉了。

有时候因为过期 Entry 任务还没执行完，更多的 Entry 被放入缓存，导致缓存的 Entry 个数短暂超过了这个限制

配置了 maximumSize 就不能配置下面的 maximumWeight 和 weigher

2. 创建一个自定义权重限制容量的 Cache

Cache> stringListCache = Caffeine.newBuilder()

//最大weight值，当所有entry的weight和快达到这个限制的时候会发生缓存过期，剔除一些缓存

.maximumWeight(1000)

//每个 Entry 的 weight 值

.weigher(new Weigher>() {

@Override

public @NonNegative int weigh(@NonNull String key, @NonNull List value) {

return value.size();

}

})

.build();

当你的缓存的 Key 或者 Value 比较大的时候，想灵活地控制缓存大小，可以使用这种方式。上面我们的 key 是一个 list，以 list 的大小作为 Entry 的大小。 当把 Weigher 实现为只返回1，maximumWeight 其实和 maximumSize 是等效的。 同样的，为了性能考虑，这个限制也不会很死板。

在这里，我们提出第一个问题：Entry是怎么保存，怎么过期的呢？

3. 指定初始大小

Cache cache = Caffeine.newBuilder()

//指定初始大小

.initialCapacity(1000)

.build();

和HashMap类似，通过指定一个初始大小，减少扩容带来的性能损耗。这个值也不宜过大，浪费内存。

在这里，我们提出第二个问题：这个初始大小，影响那些存储参数呢？

4. 指定Key, Value为非强引用类型

Cache cache = Caffeine.newBuilder()

// 设置 key 为 WeakReference

.weakKeys()

.build();

cache = Caffeine.newBuilder()

// 设置 key 为 WeakReference

.weakKeys()

// 设置 value 为 WeakReference

.weakValues()

.build();

cache = Caffeine.newBuilder()

// 设置 key 为 WeakReference

.weakKeys()

// 设置 value 为 SofReference

.softValues()

.build();

对于 Java 中的 StrongReference，WeakReference，SoftReference，可以参考我的另外一篇文章：JDK核心JAVA源码解析(3) - 引用相关 在这里简单归纳下：StrongReference：强引用就是指在程序代码之中普遍存在的，一般的new一个对象并赋值给一个对象变量，就是一个强引用；只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。

SoftReference：软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。

WeakReference：用来描述非必须的对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示

Caffeine 中的 Key，可以是 WeakReference，但是目前不能指定为 SoftReference，所以我们在这里提出第三个问题，为什么 Key 不能指定为 SoftReference，SoftReference 为何被区别对待。

设置 Key 和 Value 的 Reference 类型，也是一种限制大小的方式，但是限制比较多：使用 weakKeys 就不能使用 Writer (这里提出第四个问题，为什么 weakKeys 和 Writer 不能同时使用)

使用 weakValues 或者 softValues 就不能使用异步缓存 buildAsync(这里提出第五个问题，为什么使用 weakValues 或者 softValues 就不能使用异步缓存)

一般通过 maximumSize 还有 maximumWeight 就能满足我们的需求。

设置过期时间相关

1. 自定义过期

Cache cache = Caffeine.newBuilder()

.expireAfter(new Expiry() {

@Override

//设置 Entry 创建后的过期时间

//这里设置为 60s 后过期

public long expireAfterCreate(@NonNull String key, @NonNull Order value, long currentTime) {

return 1000 * 1000 * 1000 * 60;

}

@Override

//设置 Entry 更新后的过期时间

//这里返回 currentDuration 表示永远不过期

public long expireAfterUpdate(@NonNull String key, @NonNull Order value, long currentTime, @NonNegative long currentDuration) {

return currentDuration;

}

@Override

//设置 Entry 读取后的过期时间

//这里设置为 Order 的 createTime 的 60s 后过期

public long expireAfterRead(@NonNull String key, @NonNull Order value, long currentTime, @NonNegative long currentDuration) {

return 1000 * 1000 * 1000 * 60 - (System.currentTimeMillis() - value.createTime()) * 1000;

}

})

.build();

通过实现 Expiry 接口，设置过期策略。这个接口主要包括三个值：Entry 创建后的过期时间：参数为 Entry 的 Key 还有 Value，以及 Entry 创建时间。需要返回的是这个 Entry 的生育过期时间，单位是 nanoSeconds

Entry 更新后的过期时间：参数为 Entry 的 Key 还有 Value，以及当前时间(并不是系统当前时间，而是 Ticker 里面的当前时间，如果需要获取系统当前时间需要自己手动获取)和当前剩余的过期时间。需要返回的是这个 Entry 的剩余过期时间，单位是 nanoSeconds。如果永远不过期，可以返回 currentDuration 表示剩余时间永远不变，永远不过期。

Entry 读取后的过期时间：参数为 Entry 的 Key 还有 Value，以及当前时间(并不是系统当前时间，而是 Ticker 里面的当前时间，如果需要获取系统当前时间需要自己手动获取)和当前剩余的过期时间。需要返回的是这个 Entry 的剩余时间，单位是 nanoSeconds。如果永远不过期，可以返回 currentDuration 表示剩余时间永远不变，永远不过期。

这个配置与接下来的 expireAfterWrite 和 expireAfterAccess 互斥。不能同时配置

** 2. 设置写入以及更新后过期**

Cache cache = Caffeine.newBuilder()

//写入或者更新1分钟后，缓存过期并失效

.expireAfterWrite(1, TimeUnit.MINUTES)

.build();

这个配置与上面的 expireAfter 互斥，不能同时配置

** 3. 设置操作后过期**

Cache cache = Caffeine.newBuilder()

//写入或者更新或者读取1分钟后，缓存过期并失效

.expireAfterAccess(1, TimeUnit.MINUTES)

.build();

这个配置与上面的 expireAfter 互斥，不能同时配置

LoadingCache 相关

** 1. 生成LoadingCache **

Cache cache = Caffeine.newBuilder()

//使用 CacheLoader 初始化

.build(key -> {

return loadFromDB(key);

});

当 Key 不存在或者已过期时，会调用 CacheLoader 重新加载这个 Key。那么，这里要提出下面这些问题：Key 是否可以为 Null，为什么

调用 CacheLoader 的时候，如果有异常会怎样

2. 设置定时重新加载时间

Cache cache = Caffeine.newBuilder()

//设置在写入或者更新之后1分钟后，调用 CacheLoader 重新加载

.refreshAfterWrite(1, TimeUnit.MINUTES)

//使用 CacheLoader 初始化

.build(key -> {

return loadFromDB(key);

});

注意设置了这个配置，就只能通过build(CacheLoader)来生成 LoadingCache，不能生成普通的 Cache 了

额外配置

1. 统计记录相关

Cache cache = Caffeine.newBuilder()

//打开数据采集

.recordStats().build();

Cache cache = Caffeine.newBuilder()

//自定义数据采集器

.recordStats(() -> new StatsCounter() {

@Override

public void recordHits(@NonNegative int count) {

}

@Override

public void recordMisses(@NonNegative int count) {

}

@Override

public void recordLoadSuccess(@NonNegative long loadTime) {

}

@Override

public void recordLoadFailure(@NonNegative long loadTime) {

}

@Override

public void recordEviction() {

}

@Override

public void recordEviction(@NonNegative int weight) {

}

@Override

public void recordEviction(@NonNegative int weight, RemovalCause cause) {

}

@Override

public @NonNull CacheStats snapshot() {

return null;

}

}).build();

这里我们提出两个问题：默认的数据采集是否会影响性能

数据采集都会采集哪些数据

2. 某个 Entry 过期被移除后的回调

Cache cache = Caffeine

.newBuilder()

.removalListener((key, value, cause) -> {

log.info("{}, {}, {}", key, value, cause);

})

.build();

回调里面有三个参数，包括 Entry 的 Key， Entry 的 Value 以及移除原因 cause。这个原因是一个枚举类型：

public enum RemovalCause {

EXPLICIT {

@Override public boolean wasEvicted() {

return false;

}

},

REPLACED {

@Override public boolean wasEvicted() {

return false;

}

},

COLLECTED {

@Override

public boolean wasEvicted() {

return true;

}

},

EXPIRED {

@Override

public boolean wasEvicted() {

return true;

}

},

SIZE {

@Override

public boolean wasEvicted() {

return true;

}

};

}

这里再提出一个问题：失效原因究竟对应哪些 API 的操作导致的失效？

3. 缓存主动更新其他存储或者资源

我们还可以通过设置 Writer，将对于缓存的更新，作用于其他存储，例如数据库：

Cache cache = Caffeine.newBuilder()

.writer(new CacheWriter() {

@Override

public void write(@NonNull String key, @NonNull Object value) {

//缓存更新时(包括创建和修改，不包括load)，回调这里

//数据库更新

db.upsert(key, value);

}

@Override

public void delete(@NonNull String key, @Nullable Object value, @NonNull RemovalCause cause) {

//缓存失效时(包括任何原因的失效)，回调这里

//数据库更新

db.markAsDeleted(key, value);

}

})

.build();

那么就引出了如下几个问题：如果回调发生异常，会怎么处理？

具体哪些 API 会引发 write，哪些会引发 delete

异步缓存

1. 生成异步缓存

AsyncCache cache = Caffeine.newBuilder()

//生成异步缓存

.buildAsync();

这种缓存，获取的 Value 都是一个 CompletableFuture。

**2. 生成异步 LoadingCache **

AsyncCache cache = Caffeine.newBuilder()

//生成异步缓存

.buildAsync(key -> {

return loadFromDB(key);

});

3. 设置异步任务线程池

AsyncCache cache = Caffeine.newBuilder()

.executor(new ForkJoinPool(10))

//生成异步缓存

.buildAsync();

这里我们提出如下问题：异步缓存里面，哪些操作是异步的？

这些异步任务，执行的线程池默认是哪个？

异步任务有异常，如何处理？

到这里我们基本把创建说完了，接下来看一下使用这些缓存：

Cache syncCache = Caffeine.newBuilder().build();

//加入缓存

syncCache.put(key, value);

//批量加入

syncCache.putAll(keyValueMap);

//读取缓存，如果不存在，则执行后面的mappingFunction读取并放入缓存

syncCache.get(key, k -> {

return readFromOther(k);

});

//批量读取

syncCache.getAll(keys, ks -> {

return readFromOther(k);

});

//获取缓存配置信息，以及其他维度的信息

Policy policy = syncCache.policy();

//获取统计信息，前提是必须打开统计

CacheStats stats = syncCache.stats();

//获取某个key，如果不存在则返回null

syncCache.getIfPresent(key);

//将map转换为map，对map的修改会影响缓存

ConcurrentMap map = syncCache.asMap();

//让某个key生效

syncCache.invalidate(key);

//让所有key失效

syncCache.invalidateAll();

//批量失效

syncCache.invalidateAll(keys);

//估计大小

@NonNegative long estimatedSize = syncCache.estimatedSize();

//等待过期清理任务完成，让缓存处于一个稳定状态

syncCache.cleanUp();

这里只提了同步缓存，异步缓存的 API 类似，只是取值变成了 CompletableFuture 包装的

接下来的章节，我们会深入研究 Caffeine 的源代码和实现原理及思想