Guava Cache 是非常强大的本地缓存工具，提供了非常简单 API 供开发者使用。
这篇文章，我们将详细介绍 Guava Cache 的基本用法、回收策略，刷新策略，实现原理。
1 基本用法
1.1 依赖配置
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.0.1-jre</version>
</dependency>
1.1 创建缓存
Guava Cache 提供了基于 Builder 构建者模式的构造器，用户只需要根据需求设置好各种参数即可使用。
1、手工创建缓存对象
@Test
public void testHandCache() {
// 测试手工测试
Cache<String, String> cache = CacheBuilder.newBuilder().
// 最大容量为20（基于容量进行回收）
maximumSize(20)
// 配置写入后多久未更新，缓存会过期
.expireAfterWrite(10, TimeUnit.SECONDS).build();
cache.put("hello", "value_HELLO");
assertEquals("value_HELLO", cache.getIfPresent("hello"));
Thread.sleep(10000);
// 过期后重新获取
assertNull(cache.getIfPresent("hello"));
}
我们可以创建一个缓存对象 Cache ，通过 CacheBuilder 构造器，配置相关参数（最大容量 20 个条目、缓存过期时间 10 秒），最后调用构建方法。
2、创建缓存加载器
CacheLoader 可以理解为一个固定的加载器，在创建 Cache 对象时指定，然后简单地重写 V load(K key) throws Exception 方法，就可以达到当检索不存在的时候，会自动的加载数据。
@Test
public void testLoadingCache() throws InterruptedException, ExecutionException {
CacheLoader<String, String> cacheLoader = new CacheLoader<String, String>() {
//自动写缓存数据的方法
@Override
public String load(String key) {
System.out.println("加载 key:" + key);
return"value_" + key.toUpperCase();
}
@Override
//重新刷新缓存
public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
returnsuper.reload(key, oldValue);
}
};
LoadingCache<String, String> cache =
CacheBuilder.newBuilder()
// 最大容量为100（基于容量进行回收）
.maximumSize(20)
// 配置写入后多久未更新，缓存会过期
.expireAfterWrite(10, TimeUnit.SECONDS)
//配置写入后多久刷新缓存
.refreshAfterWrite(1, TimeUnit.SECONDS).build(cacheLoader);
assertEquals(0, cache.size());
assertEquals("value_HELLO", cache.getUnchecked("hello"));
assertEquals(1, cache.size());
// 通过 Callable 获取数据
String key = "mykey";
String value = cache.get(key, new Callable<String>() {
@Override
public String call() throws Exception {
return"call_" + key;
}
});
System.out.println("call value:" + value);
}
和手工创建缓存对象不同，我们首先创建缓存加载器对象，并重写 load 方法，然后通过缓存构造器创建 LoadingCache 对象 ，该对象支持写入后刷新方法。
同时 LoadingCache 对象支持 Callable 模式，也就是调用 get 方法时，可以传入 Callable 对象。这样可以在使用缓存时，更加灵活。
2 回收策略
Guava Cache 提供了三种基本的缓存回收方式：
-
基于容量回收策略
-
基于时间的回收策略
-
基于引用回收策略
2.1 基于容量回收策略
基于容量的回收策略可以分为两种：基于大小和基于权重。
基于大小：我们可以使用 maximumSize 方法设置最大缓存项数量，当缓存项数量达到设定的最大值时，旧的缓存项将会被移除。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
.maximumSize(100)
.build();
基于权重：如果不同的缓存值，需要占据不同的内存空间，也就是不同的缓存项有不同的“权重”（weights）。
我们可以使用 CacheBuilder.weigher(Weigher) 指定一个权重函数，并且用 maximumWeight(long) 指定最大总重。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
.maximumWeight(1000)
.weigher(new Weigher<Object, Object>() {
public int weigh(Object key, Object value) {
// 定义权重计算方法
return value.size();
}
}).build();
2.2 基于时间的回收策略
我们可以使用 expireAfterAccess 和 expireAfterWrite 方法设置缓存项的最大存活时间。
-
expireAfterAccess表示缓存项在给定时间内没有被读/写访问会过期。 -
expireAfterWrite表示缓存项在被创建或最后一次更新后的指定时间内会过期。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
// 10分钟没有访问后会被回收，或者重新加载
.expireAfterAccess(10, TimeUnit.MINUTES)
// 5分钟没有更新,缓存会被回收，或者重新加载
// .expireAfterWrite(5,TimeUnit.MINUTES)
.build();
2.3 基于引用回收策略
Guava Cache 提供了以下三个方法来配置基于引用的回收策略：
-
weakKeys() 方法：
通过调用
weakKeys()方法，可以使缓存中的键使用弱引用。这意味着如果某个键没有其他强引用指向它，那么该键可能会被垃圾回收，并且相应的缓存项也会被移除。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
.weakKeys()
.build();
-
weakValues() 方法：
通过调用
weakValues()方法，可以使缓存中的值使用弱引用。这样，如果某个值没有其他强引用指向它，那么该值可能会被垃圾回收，相应的缓存项也会被移除。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
.weakValues()
.build();
-
softValues() 方法：
通过调用
softValues()方法，可以使缓存中的值使用软引用。软引用相对于弱引用，更倾向于在内存不足时被垃圾回收。如果某个值没有其他强引用指向它，且内存不足时，该值可能会被垃圾回收，相应的缓存项也会被移除。
Cache<Object, Object> cache = CacheBuilder.newBuilder()
.softValues()
.build();
一般来讲，我们在生产环境使用的是(基于容量回收策略 + 基于时间的回收策略)两者配合来使用。
当然 ，我们同样可以使用手工回收的方式。
Cache<String,String> cache = CacheBuilder.newBuilder().build();
Object value = new Object();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");
//1.清除指定的key
cache.invalidate("key1");
//2.批量清除list中全部key对应的记录
List<String> list = new ArrayList<String>();
list.add("key1");
list.add("key2");
cache.invalidateAll(list);
3 刷新策略
3.1 手工刷新
我们可以强制缓存加载器重新加载键的新值，调用 LoadingCache 对象的刷新方法。
String value = loadingCache.get("key");
loadingCache.refresh("key");
3.2 自动刷新
Guava Cache 提供了刷新（refresh）机制，可以通过 refreshAfterWrite 方法来设置刷新时间，当缓存项过期的同时可以重新加载新值。
Cache<String, String> cache = CacheBuilder.newBuilder()
.refreshAfterWrite(5, TimeUnit.MINUTES)
// 设置并发级别为3，并发级别是指可以同时写缓存的线程数
.concurrencyLevel(3)
.build(new CacheLoader<String, String>() {
@Override
public String load(String key) throws Exception {
// 异步加载新值的逻辑
return fetchDataFromDataSource(key);
}
});
// 在获取缓存值时，如果缓存项过期，将返回旧值
String value = cache.get("exampleKey");
配置刷新方法 refreshAfterWrite，当大量线程同时访问缓存项，缓存已过期时，更新线程调用 load 方法更新该缓存，其他请求线程并不需要等待，框架直接返回该缓存项的旧值。
因为更新线程同时也是请求线程，所以在上面的示例代码里面，刷新缓存是个同步操作，可不可以异步的加载缓存呢 ？
我们有两种方式：异步加载缓存的原理是重写 reload 方法。
@Test
public void testAnsynRefreshMethod1() throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(5);
CacheLoader<String, String> cacheLoader = new CacheLoader<String, String>() {
//自动写缓存数据的方法
@Override
public String load(String key) {
System.out.println(Thread.currentThread().getName() + " 加载 key:" + key);
// 从数据库加载数据
return"value_" + key.toUpperCase();
}
@Override
//异步刷新缓存
public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
ListenableFutureTask<String> futureTask = ListenableFutureTask.create(() -> {
System.out.println(Thread.currentThread().getName() + " 异步加载 key:" + key + " oldValue:" + oldValue);
Thread.sleep(1000);
return load(key);
});
executorService.submit(futureTask);
return futureTask;
}
};
LoadingCache<String, String> cache = CacheBuilder.newBuilder()
// 最大容量为20（基于容量进行回收）
.maximumSize(20)
//配置写入后多久刷新缓存
.refreshAfterWrite(2, TimeUnit.SECONDS).build(cacheLoader);
String key = "hello";
// 第一次加载
String value = cache.get(key);
System.out.println(value);
Thread.sleep(3000);
for (int i = 0; i < 10; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
try {
String value2 = cache.get(key);
System.out.println(Thread.currentThread().getName() + value2);
// 第二次加载
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
Thread.sleep(20000);
}
或者使用更优雅的使用方式：
ExecutorService executorService = Executors.newFixedThreadPool(5);
CacheLoader<String, String> cacheLoader = CacheLoader.asyncReloading(
new CacheLoader<String, String>() {
//自动写缓存数据的方法
@Override
public String load(String key) {
System.out.println(Thread.currentThread().getName() + " 加载 key:" + key);
// 从数据库加载数据
return "value_" + key.toUpperCase();
}
} , executorService);
自动刷新的缺点是：当缓存项到了指定过期时间，不管是同步刷新还是异步刷新，绝大部分请求线程都会返回旧的数据值，缓存值会有一定的延迟效果。
所以一般场景下，使用efreshAfterWrite和 expireAfterWrite配合使用 。
比如说控制缓存每1秒进行刷新，如果超过 2s 没有访问，那么则让缓存失效，访问时不会得到旧值，而是必须得待新值加载。
4 实现原理
Guava Cache 的数据结构跟 JDK1.7 的 ConcurrentHashMap 类似，如下图所示：
4.1 构造函数
public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
CacheLoader<? super K1, V1> loader) {
checkWeightWithWeigher();
return new LocalCache.LocalLoadingCache<>(this, loader);
}
通过构造器 CacheBuilder 的构建方法创建本地缓存类 LocalCache 的静态包装类 LocalLoadingCache对象。
class LocalCache<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {
// ..... 省略代码
staticclass LocalLoadingCache<K, V> extends LocalManualCache<K, V>
implements LoadingCache<K, V> {
LocalLoadingCache(
CacheBuilder<? super K, ? super V> builder, CacheLoader<? super K, V> loader) {
super(new LocalCache<K, V>(builder, checkNotNull(loader)));
}
// LoadingCache methods
@Override
public V get(K key) throws ExecutionException {
return localCache.getOrLoad(key);
}
@Override
public V getUnchecked(K key) {
try {
return get(key);
} catch (ExecutionException e) {
thrownew UncheckedExecutionException(e.getCause());
}
}
@Override
public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
return localCache.getAll(keys);
}
@Override
public void refresh(K key) {
localCache.refresh(key);
}
// ..... 省略代码
}
}
LocalLoadingCache 类对外暴露了若干方法，它的底层依然是 LocalCache 对象来执行相关缓存操作，LocalCache 本质上就是一个 Map 。
4.2 初始化缓存
LocalCache(
CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
// key的强度，即引用类型的强弱
keyStrength = builder.getKeyStrength();
// value的强度，即引用类型的强弱
valueStrength = builder.getValueStrength();
// key的比较策略，跟key的引用类型有关
keyEquivalence = builder.getKeyEquivalence();
// value的比较策略，跟value的引用类型有关
valueEquivalence = builder.getValueEquivalence();
maxWeight = builder.getMaximumWeight();
weigher = builder.getWeigher();
//访问后的过期时间，设置了expireAfterAccess参数
expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
//写入后的过期时间，设置了expireAfterWrite参数
expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
refreshNanos = builder.getRefreshNanos();
int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
if (evictsBySize() && !customWeigher()) {
initialCapacity = (int) Math.min(initialCapacity, maxWeight);
}
// Find the lowest power-of-two segmentCount that exceeds concurrencyLevel, unless
// maximumSize/Weight is specified in which case ensure that each segment gets at least 10
// entries. The special casing for size-based eviction is only necessary because that eviction
// happens per segment instead of globally, so too many segments compared to the maximum size
// will result in random eviction behavior.
int segmentShift = 0;
int segmentCount = 1;
while (segmentCount < concurrencyLevel && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
++segmentShift;
segmentCount <<= 1;
}
this.segmentShift = 32 - segmentShift;
segmentMask = segmentCount - 1;
this.segments = newSegmentArray(segmentCount);
int segmentCapacity = initialCapacity / segmentCount;
if (segmentCapacity * segmentCount < initialCapacity) {
++segmentCapacity;
}
int segmentSize = 1;
while (segmentSize < segmentCapacity) {
segmentSize <<= 1;
}
if (evictsBySize()) {
// Ensure sum of segment max weights = overall max weights
long maxSegmentWeight = maxWeight / segmentCount + 1;
long remainder = maxWeight % segmentCount;
for (int i = 0; i < this.segments.length; ++i) {
if (i == remainder) {
maxSegmentWeight--;
}
this.segments[i] =
createSegment(segmentSize, maxSegmentWeight, builder.getStatsCounterSupplier().get());
}
} else {
for (int i = 0; i < this.segments.length; ++i) {
this.segments[i] =
createSegment(segmentSize, UNSET_INT, builder.getStatsCounterSupplier().get());
}
}
}
LocalCache 维护一个 Segment 数组，数组大小满足如下条件：
-
数组大小是 2 的幂次 ，并且小于并发度 concurrencyLevel ；
-
若指定了容量大小，数组大小乘以 20 要大于缓存权重 maxWeight （假如设置容量大小最大值为40，那么 maxWeight 为 40 ）。
接下来，我们看看 Segment 类的核心属性 ：
static class Segment<K, V> extends ReentrantLock {
// 存活的元素大小
volatileint count;
// 存活的元素权重
long totalWeight;
//修改、更新的数量，用来做弱一致性
int modCount;
//扩容用
int threshold;
//存放Entry的数组，用来存放Entry，使用AtomicReferenceArray是因为要用CAS来保证原子性
volatile@Nullable AtomicReferenceArray<ReferenceEntry<K, V>> table;
//如果key是弱引用的话，那么被 GC 回收后，就会放到ReferenceQueue，要根据这个queue做一些清理工作
final@Nullable ReferenceQueue<K> keyReferenceQueue;
//如果value是弱引用的话，那么被 GC 回收后，就会放到ReferenceQueue，要根据这个queue做一些清理工作
final@Nullable ReferenceQueue<V> valueReferenceQueue;
//记录哪些entry被访问，用于accessQueue的更新。
final Queue<ReferenceEntry<K, V>> recencyQueue;
// 读取次数计数器
final AtomicInteger readCount = new AtomicInteger();
// 如果一个元素新写入，则会记到这个队列的尾部，用来做expire
@GuardedBy("this")
final Queue<ReferenceEntry<K, V>> writeQueue;
//读、写都会放到这个队列，用来进行LRU替换算法
@GuardedBy("this")
final Queue<ReferenceEntry<K, V>> accessQueue;
}
ReferenceEntry 有几种引用类型 ：
下图展示了 StringEntry 核心属性 ：
每种 Entry 对象都有 Next 属性 ，指向下一个 Entry 。对象值 valueReference 默认是一个占位符 unSet ，表示没有被设置过值。
4.3 查询流程
进入 LoadingCache 的 get(key) 方法 ， 如下代码所示：
// 1.调用LoadingCache的getOrLoad
V getOrLoad(K key) throws ExecutionException {
return get(key, defaultLoader);
}
// 2.计算 key 的哈希值，并判断位于哪一个段 Segment，最后通过查询
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
int hash = hash(checkNotNull(key));
return segmentFor(hash).get(key, hash, loader);
}
01 计算 key 对应的哈希值
int hash(@Nullable Object key) {
int h = keyEquivalence.hash(key);
return rehash(h);
}
02 定位分段 Segment
Segment<K, V> segmentFor(int hash) {
// segmentMask = segmentCount - 1
return segments[(hash >>> segmentShift) & segmentMask];
}
第二步骤，和 ConcurrentHashMap 类似，通过哈希值计算数据存储在哪一个分段 Segment 。
03 从定位的分段查询出对象
V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
// 判断 key、loader 是否为空
checkNotNull(key);
checkNotNull(loader);
try {
if (count != 0) { // read-volatile
// don't call getLiveEntry, which would ignore loading values
// 根据hash定位到 table 的第一个 Entry
ReferenceEntry<K, V> e = getEntry(key, hash);
if (e != null) {
// 获取当前时间
long now = map.ticker.read();
// 获取当前存活的 Value
V value = getLiveValue(e, now);
if (value != null) {
//记录被访问过
recordRead(e, now);
//记录命中率
statsCounter.recordHits(1);
//判断是否需要刷新，如果需要刷新，那么会去异步刷新，且返回旧值。
return scheduleRefresh(e, key, hash, value, now, loader);
}
ValueReference<K, V> valueReference = e.getValueReference();
//如果 Entry 过期了且数据还在加载中，则等待直到加载完成。
if (valueReference.isLoading()) {
return waitForLoadingValue(e, key, valueReference);
}
}
}
// at this point e is either null or expired;
// 走到这一步表示: 之前没有写入过数据 || 数据已经过期 || 数据不是在加载中。
return lockedGetOrLoad(key, hash, loader);
} catch (ExecutionException ee) {
Throwable cause = ee.getCause();
if (cause instanceof Error) {
thrownew ExecutionError((Error) cause);
} elseif (cause instanceof RuntimeException) {
thrownew UncheckedExecutionException(cause);
}
throw ee;
} finally {
postReadCleanup();
}
}
A 定位第一个Entry
ReferenceEntry<K, V> getEntry(Object key, int hash) {
for (ReferenceEntry<K, V> e = getFirst(hash); e != null; e = e.getNext()) {
// 判断哈希值
if (e.getHash() != hash) {
continue;
}
// 判断key
K entryKey = e.getKey();
if (entryKey == null) {
tryDrainReferenceQueues();
continue;
}
if (map.keyEquivalence.equivalent(key, entryKey)) {
return e;
}
}
returnnull;
}
B 从第一个 Entry 获取存活的值
V getLiveValue(ReferenceEntry<K, V> entry, long now) {
if (entry.getKey() == null) {
tryDrainReferenceQueues();
return null;
}
V value = entry.getValueReference().get();
if (value == null) {
tryDrainReferenceQueues();
return null;
}
if (map.isExpired(entry, now)) {
tryExpireEntries(now);
return null;
}
return value;
}
boolean isExpired(ReferenceEntry<K, V> entry, long now) {
checkNotNull(entry);
// 如果配置了 expireAfterAccess ，比较当前时间和 Entry 的 accessTime 比较
if (expiresAfterAccess() && (now - entry.getAccessTime() >= expireAfterAccessNanos)) {
returntrue;
}
// 如果配置了 expireAfterWrite ，比较当前时间和 Entry 的 writeTime 比较
if (expiresAfterWrite() && (now - entry.getWriteTime() >= expireAfterWriteNanos)) {
returntrue;
}
returnfalse;
}
假如 Entry 的 key 为空，或者 vlaue 为空，或者过期了，则返回空 。
C 调度刷新 scheduleRefresh
V scheduleRefresh(
ReferenceEntry<K, V> entry,
K key,
int hash,
V oldValue,
long now,
CacheLoader<? super K, V> loader) {
//1、是否配置了 refreshAfterWrite
//2、用 writeTime 判断是否达到刷新的时间
//3、是否在加载中，如果是则没必要再进行刷新
if (map.refreshes()
&& (now - entry.getWriteTime() > map.refreshNanos)
&& !entry.getValueReference().isLoading()) {
V newValue = refresh(key, hash, loader, true);
if (newValue != null) {
return newValue;
}
}
return oldValue;
}
调度刷新方法会判断三个条件 ：
-
配置了刷新时间 refreshAfterWrite
-
当前时间减去 Entry 的写入时间大于刷新时间
-
当前 Entry 未处于加载中
当满足了三个条件之后，调用 refresh 方法，当异步加载成功后，返回新值。
V refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {
//插入一个 LoadingValueReference ，实质是把对应Entry的ValueReference替换为新建的LoadingValueReference
final LoadingValueReference<K, V> loadingValueReference =
insertLoadingValueReference(key, hash, checkTime);
if (loadingValueReference == null) {
returnnull;
}
// 调用异步加载方法loadAsync
ListenableFuture<V> result = loadAsync(key, hash, loadingValueReference, loader);
if (result.isDone()) {
try {
return Uninterruptibles.getUninterruptibly(result);
} catch (Throwable t) {
// don't let refresh exceptions propagate; error was already logged
}
}
returnnull;
}
首先将 Entry 对象的 ValueReference 包装为新建的 LoadingValueReference , 表明当前对象正在加载中。
LoadingValueReference<K, V> insertLoadingValueReference(
final K key, final int hash, boolean checkTime) {
ReferenceEntry<K, V> e = null;
lock();
try {
long now = map.ticker.read();
preWriteCleanup(now);
AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
int index = hash & (table.length() - 1);
ReferenceEntry<K, V> first = table.get(index);
// Look for an existing entry.
for (e = first; e != null; e = e.getNext()) {
K entryKey = e.getKey();
if (e.getHash() == hash
&& entryKey != null
&& map.keyEquivalence.equivalent(key, entryKey)) {
// We found an existing entry.
ValueReference<K, V> valueReference = e.getValueReference();
if (valueReference.isLoading()
|| (checkTime && (now - e.getWriteTime() < map.refreshNanos))) {
// refresh is a no-op if loading is pending
// if checkTime, we want to check *after* acquiring the lock if refresh still needs
// to be scheduled
returnnull;
}
// continue returning old value while loading
++modCount;
LoadingValueReference<K, V> loadingValueReference =
new LoadingValueReference<>(valueReference);
e.setValueReference(loadingValueReference);
return loadingValueReference;
}
}
++modCount;
LoadingValueReference<K, V> loadingValueReference = new LoadingValueReference<>();
e = newEntry(key, hash, first);
e.setValueReference(loadingValueReference);
table.set(index, e);
return loadingValueReference;
} finally {
unlock();
postWriteCleanup();
}
}
接下来，分析异步加载loadAsync方法：
ListenableFuture<V> loadAsync(
final K key,
final int hash,
final LoadingValueReference<K, V> loadingValueReference,
CacheLoader<? super K, V> loader) {
final ListenableFuture<V> loadingFuture = loadingValueReference.loadFuture(key, loader);
loadingFuture.addListener(
new Runnable() {
@Override
public void run() {
try {
getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
} catch (Throwable t) {
logger.log(Level.WARNING, "Exception thrown during refresh", t);
loadingValueReference.setException(t);
}
}
},
directExecutor());
return loadingFuture;
}
public ListenableFuture<V> loadFuture(K key, CacheLoader<? super K, V> loader) {
try {
// 记录耗时时间
stopwatch.start();
V previousValue = oldValue.get();
if (previousValue == null) {
V newValue = loader.load(key);
return set(newValue) ? futureValue : Futures.immediateFuture(newValue);
}
ListenableFuture<V> newValue = loader.reload(key, previousValue);
if (newValue == null) {
return Futures.immediateFuture(null);
}
// To avoid a race, make sure the refreshed value is set into loadingValueReference
// *before* returning newValue from the cache query.
return transform(
newValue,
new com.google.common.base.Function<V, V>() {
@Override
public V apply(V newValue) {
LoadingValueReference.this.set(newValue);
return newValue;
}
},
directExecutor());
} catch (Throwable t) {
ListenableFuture<V> result = setException(t) ? futureValue : fullyFailedFuture(t);
if (t instanceof InterruptedException) {
Thread.currentThread().interrupt();
}
return result;
}
}
loadAsync 方法流程：
-
调用 loadingValueReference 对象的 loadFuture 方法，假如旧数据为空值，则同步调用加载器 loader 的 load 方法 ，并返回包装了新值的 Future 。
-
假如旧数据不为空值，则调用加载器 loader 的 reload 方法（此处可以重新实现为异步的方式），经过转换操作返回包装了新值的 Future 。
-
将新的值存储在 Entry 对象里。
D 查询/加载 lockedGetOrLoad
如果之前没有写入过数据 、 数据已经过期、 数据不是在加载中，则会调用lockedGetOrLoad方法。
V lockedGetOrLoad(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
ReferenceEntry<K, V> e;
ValueReference<K, V> valueReference = null;
LoadingValueReference<K, V> loadingValueReference = null;
//用来判断是否需要创建一个新的Entry
boolean createNewEntry = true;
//segment上锁
lock();
try {
// re-read ticker once inside the lock
long now = map.ticker.read();
//做一些清理工作
preWriteCleanup(now);
int newCount = this.count - 1;
AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
int index = hash & (table.length() - 1);
ReferenceEntry<K, V> first = table.get(index);
//通过key定位entry
for (e = first; e != null; e = e.getNext()) {
K entryKey = e.getKey();
if (e.getHash() == hash
&& entryKey != null
&& map.keyEquivalence.equivalent(key, entryKey)) {
//找到entry
valueReference = e.getValueReference();
//如果value在加载中则不需要重复创建entry
if (valueReference.isLoading()) {
createNewEntry = false;
} else {
V value = valueReference.get();
//value为null说明已经过期且被清理掉了
if (value == null) {
//写通知queue
enqueueNotification(
entryKey, hash, value, valueReference.getWeight(), RemovalCause.COLLECTED);
//过期但还没被清理
} elseif (map.isExpired(e, now)) {
//写通知queue
// This is a duplicate check, as preWriteCleanup already purged expired
// entries, but let's accomodate an incorrect expiration queue.
enqueueNotification(
entryKey, hash, value, valueReference.getWeight(), RemovalCause.EXPIRED);
} else {
recordLockedRead(e, now);
statsCounter.recordHits(1);
//其他情况则直接返回value
//来到这步，是不是觉得有点奇怪，我们分析一下:
//进入lockedGetOrLoad方法的条件是数据已经过期 || 数据不是在加载中，但是在lock之前都有可能发生并发，进而改变entry的状态，所以在上面中再次判断了isLoading和isExpired。所以来到这步说明，原来数据是过期的且在加载中，lock的前一刻加载完成了，到了这步就有值了。
return value;
}
writeQueue.remove(e);
accessQueue.remove(e);
this.count = newCount; // write-volatile
}
break;
}
}
//创建一个Entry，且set一个新的 LoadingValueReference。
if (createNewEntry) {
loadingValueReference = new LoadingValueReference<>();
if (e == null) {
e = newEntry(key, hash, first);
e.setValueReference(loadingValueReference);
table.set(index, e);
} else {
e.setValueReference(loadingValueReference);
}
}
} finally {
unlock();
postWriteCleanup();
}
//同步加载数据
if (createNewEntry) {
try {
synchronized (e) {
return loadSync(key, hash, loadingValueReference, loader);
}
} finally {
statsCounter.recordMisses(1);
}
} else {
// The entry already exists. Wait for loading.
return waitForLoadingValue(e, key, valueReference);
}
}
5 总结
通过解析 Guava Cache 的实现原理，我们发现 Guava LocalCache 与 ConcurrentHashMap 有以下不同：
-
ConcurrentHashMap ”分段控制并发“是隐式的（实现中没有Segment对象），而 LocalCache 是显式的。
在 JDK 1.8 之后，ConcurrentHashMap 采用
synchronized + CAS实现：当 put 的元素在哈希桶数组中不存在时，直接 CAS 进行写操作；在发生哈希冲突的情况下使用 synchronized 锁定头节点。其实是比分段锁更细粒度的锁实现，只在特定场景下锁定其中一个哈希桶，降低锁的影响范围。 -
Guava Cache 使用 ReferenceEntry 来封装键值对，并且对于值来说，还额外实现了 ValueReference 引用对象来封装对应 Value 对象。
-
Guava Cache 支持过期 + 自动 loader 机制，这也使得其加锁方式与 ConcurrentHashMap 不同。
-
Guava Cache 支持 segment 粒度上支持了 LRU 机制， 体现在 Segment 上就是 writeQueue 和 accessQueue。
队列中的元素按照访问或者写时间排序，新的元素会被添加到队列尾部。如果，在队列中已经存在了该元素，则会先delete掉，然后再尾部添加该节点。
1324
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
