Guava Cache 原理分析与最佳实践，2024年最新满满干货

throw ee;

} finally {

postReadCleanup();

}

}

▐  Segment#scheduleRefresh

// com.google.common.cache.LocalCache.Segment#scheduleRefresh

V scheduleRefresh(

ReferenceEntry<K, V> entry,

K key,

int hash,

V oldValue,

long now,

CacheLoader<? super K, V> loader) {

if (

// 配置了刷新策略 refreshAfterWrite

map.refreshes()

// 到刷新时间了

&& (now - entry.getWriteTime() > map.refreshNanos)

// 没在 loading

&& !entry.getValueReference().isLoading()) {

// 开始刷新，下面展开

V newValue = refresh(key, hash, loader, true);

if (newValue != null) {

return newValue;

}

}

return oldValue;

}

// com.google.common.cache.LocalCache.Segment#refresh

V refresh(K key, int hash, CacheLoader<? super K, V> loader, boolean checkTime) {

// 插入 loading 节点

final LoadingValueReference<K, V> loadingValueReference =

insertLoadingValueReference(key, hash, checkTime);

if (loadingValueReference == null) {

return null;

}

// 异步刷新，下面展开

ListenableFuture 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

}

}

return null;

}

// com.google.common.cache.LocalCache.Segment#loadAsync

ListenableFuture loadAsync(

final K key,

final int hash,

final LoadingValueReference<K, V> loadingValueReference,

CacheLoader<? super K, V> loader) {

// 通过 loader 异步加载数据，下面展开

final ListenableFuture 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;

}

// com.google.common.cache.LocalCache.LoadingValueReference#loadFuture

public ListenableFuture loadFuture(K key, CacheLoader<? super K, V> loader) {

try {

stopwatch.start();

// oldValue 指在写入 loading 节点前这个位置的值，如果这个位置之前没有值 oldValue 会被赋值为 UNSET

// UNSET.get() 值为 null ，所以这个缓存项从来没有进入缓存需要同步 load 具体原因前面提到了，如果通过

// 异步 reload ，由于没有老值会导致其他线程返回的都是 null

V previousValue = oldValue.get();

if (previousValue == null) {

V newValue = loader.load(key);

return set(newValue) ? futureValue : Futures.immediateFuture(newValue);

}

// 异步 load

ListenableFuture 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 result = setException(t) ? futureValue : fullyFailedFuture(t);

if (t instanceof InterruptedException) {

Thread.currentThread().interrupt();

}

return result;

}

}

▐  Segment#waitForLoadingValue

V waitForLoadingValue(ReferenceEntry<K, V> e, K key, ValueReference<K, V> valueReference)

throws ExecutionException {

// 首先你要是一个 loading 节点

if (!valueReference.isLoading()) {

throw new AssertionError();

}

checkState(!Thread.holdsLock(e), “Recursive load of: %s”, key);

// don’t consider expiration as we’re concurrent with loading

try {

V value = valueReference.waitForValue();

if (value == null) {

throw new InvalidCacheLoadException("CacheLoader returned null for key " + key + “.”);

}

// re-read ticker now that loading has completed

long now = map.ticker.read();

recordRead(e, now);

return value;

} finally {

statsCounter.recordMisses(1);

}

}

// com.google.common.cache.LocalCache.LoadingValueReference#waitForValue

public V waitForValue() throws ExecutionException {

return getUninterruptibly(futureValue);

}

// com.google.common.util.concurrent.Uninterruptibles#getUninterruptibly

public static V getUninterruptibly(Future future) throws ExecutionException {

boolean interrupted = false;

try {

while (true) {

try {

// hang 住，如果该线程被打断了继续回去 hang 住等结果，直到有结果返回

return future.get();

} catch (InterruptedException e) {

interrupted = true;

}

}

} finally {

if (interrupted) {

Thread.currentThread().interrupt();

}

}

}

▐  Segment#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;

boolean createNewEntry = true;

// 要对 segment 写操作 ，先加锁

lock();

try {

// re-read ticker once inside the lock

long now = map.ticker.read();

preWriteCleanup(now);

// 这里基本就是 HashMap 的代码，如果没有 segment 的数组下标冲突了就拉一个链表

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);

for (e = first; e != null; e = e.getNext()) {

K entryKey = e.getKey();

if (e.getHash() == hash

&& entryKey != null

&& map.keyEquivalence.equivalent(key, entryKey)) {

valueReference = e.getValueReference();

// 如果在加载中 不做任何处理

if (valueReference.isLoading()) {

createNewEntry = false;

} else {

V value = valueReference.get();

// 如果缓存项为 null 数据已经被删除，通知对应的 queue

if (value == null) {

enqueueNotification(

entryKey, hash, value, valueReference.getWeight(), RemovalCause.COLLECTED);

// 这个是 double check 如果缓存项过期 数据没被删除，通知对应的 queue

} else if (map.isExpired(e, now)) {

// This is a duplicate check, as preWriteCleanup already purged expired

// entries, but let’s accommodate an incorrect expiration queue.

enqueueNotification(

entryKey, hash, value, valueReference.getWeight(), RemovalCause.EXPIRED);

// 再次看到的时候这个位置有值了直接返回

} else {

recordLockedRead(e, now);

statsCounter.recordHits(1);

return value;

}

// immediately reuse invalid entries

writeQueue.remove(e);

accessQueue.remove(e);

this.count = newCount; // write-volatile

}

break;

}

}

// 没有 loading ，创建一个 loading 节点

if (createNewEntry) {

loadingValueReference = new LoadingValueReference<>();

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

写在最后

为了这次面试，也收集了很多的面试题！

以下是部分面试题截图

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

中…(img-n3wqQZ5N-1712637530984)]
[外链图片转存中…(img-9e33w1uD-1712637530985)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-fjJfp6wa-1712637530985)]

写在最后

为了这次面试，也收集了很多的面试题！

以下是部分面试题截图

[外链图片转存中…(img-ayGGnOMk-1712637530985)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-iWLTPaxG-1712637530985)]