缓存框架Guava Cache部分源码分析 推荐

在本地缓存中，最常用的就是OSCache和谷歌的Guava Cache。其中OSCache在07年就停止维护了，但它仍然被广泛的使用。谷歌的Guava Cache也是一个非常优秀的本地缓存，使用起来非常灵活，功能也十分强大，可以说是当前本地缓存中最优秀的缓存框架之一。之前我们分析了OSCache的部分源码，本篇就通过Guava Cache的部分源码，来分析一下Guava Cache的实现原理。
在分析之前，先弄清数据结构的使用。之前的文章提到，OSCache使用了一个扩展的HashTable，作为缓存的数据结构，由于在get操作上，没有使用同步的方式，通过引入一个更新状态数据结构，来控制并发访问的安全。Guava Cache也是使用一个扩展的HashTable作为其缓存数据结构，然而，在实现上，和OSCache是完全不同的。Guava Cache所用的HashTable和ConcurrentHashMap十分相似，通过引入一个Segment数组，对HashTable进行分段，通过分离锁、final以及volatile的配合，实现了并发环境下的线程安全，同时，性能也非常高（每个Segment段的操作互不影响，即使写操作，只要在不同的Segment上，也完全可以并发的执行）。具体的原理，可以参考ConcurrentHashMap的实现，这里就不进行具体的剖析了。
数据结构核心部分可以通过下面的图形表示：



CacheBuilder

CacheBuilder集成了创建缓存所需的各种参数。正如官方文档介绍的：CacheBuilder将创建一个LoadingCache和Cache的实例，该实例可以包含下面任何特性

自动将内容加载到缓存中

LRU淘汰策略

根据上一次访问时间或写入时间决定缓存过期

key关键字可以采用弱引用（WeakReference）

value值可以采用弱引用（WeakReference）以及软引用（SoftReference）

缓存移除或回收进行通知

统计缓存访问性能信息

所有特性都是可选的，创建的缓存可以包含上面所有的特性，也可以都不使用，具有很强的灵活性。
下面是一个简单的使用例子：

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
.maximumSize(10000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.removalListener(MY_LISTENER)
.build(
new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
return createExpensiveGraph(key);
}
});}

还可以这样写：

String spec = "maximumSize=10000,expireAfterWrite=10m";

LoadingCache<Key, Graph> graphs = CacheBuilder.from(spec)
.removalListener(MY_LISTENER)
.build(
new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
return createExpensiveGraph(key);
}
});}

说明：上面的例子指定Cache容量最大为10000，并且写入后经过10分钟自动过期，并指定了一个缓存移除的消息监听器，可以在缓存移除的时候，进行指定的操作。

接下来，根据CacheBuilder的源码进行简要的分析：
CacheBuilder中一些重要的参数：

//默认容量
private static final int DEFAULT_INITIAL_CAPACITY = 16;
//默认并发程度（segement大小就是通过这个计算）
private static final int DEFAULT_CONCURRENCY_LEVEL = 4;
//默认失效时间
private static final int DEFAULT_EXPIRATION_NANOS = 0;
//默认刷新时间
private static final int DEFAULT_REFRESH_NANOS = 0;
//默认性能计数器
static final Supplier<? extends StatsCounter> NULL_STATS_COUNTER = Suppliers.ofInstance(
new StatsCounter() {
@Override
public void recordHits(int count) {}

@Override
public void recordMisses(int count) {}

@Override
public void recordLoadSuccess(long loadTime) {}

@Override
public void recordLoadException(long loadTime) {}

@Override
public void recordEviction() {}

@Override
public CacheStats snapshot() {
return EMPTY_STATS;
}
});
static final CacheStats EMPTY_STATS = new CacheStats(0, 0, 0, 0, 0, 0);

static final Supplier<StatsCounter> CACHE_STATS_COUNTER =
new Supplier<StatsCounter>() {
@Override
public StatsCounter get() {
return new SimpleStatsCounter();
}
};
//移除事件监听器（默认为空）
enum NullListener implements RemovalListener<Object, Object> {
INSTANCE;

@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {}
}

enum OneWeigher implements Weigher<Object, Object> {
INSTANCE;

@Override
public int weigh(Object key, Object value) {
return 1;
}
}

static final Ticker NULL_TICKER = new Ticker() {
@Override
public long read() {
return 0;
}
};

static final int UNSET_INT = -1;

boolean strictParsing = true;
//初始容量
int initialCapacity = UNSET_INT;
//并发程度，Segment数组的大小通过这个进行计算，后面会进行介绍
int concurrencyLevel = UNSET_INT;
//缓存最大容量
long maximumSize = UNSET_INT;
//
long maximumWeight = UNSET_INT;
Weigher<? super K, ? super V> weigher;

//引用类型（默认都为强引用）
Strength keyStrength;
Strength valueStrength;
//写入后过期时间
long expireAfterWriteNanos = UNSET_INT;
//读取后过期时间
long expireAfterAccessNanos = UNSET_INT;
//刷新时间
long refreshNanos = UNSET_INT;

//判断是否相同的方法（因为有引用类型可以为弱引用和软引用）
Equivalence<Object> keyEquivalence;
Equivalence<Object> valueEquivalence;

RemovalListener<? super K, ? super V> removalListener;
Ticker ticker;

Supplier<? extends StatsCounter> statsCounterSupplier = NULL_STATS_COUNTER;

说明：上面就是创建缓存涉及的参数，我们可以人工指定，也可以使用默认值。我们可以看看NULL_STATS_COUNTER、NullListener的定义，其对各个方法的实现进行了重写，函数内容直接为空，这也是为了不影响性能的做法。CacheBuilder将创建缓存方法进行了封装，是值得我们借鉴的地方。

Guava Cache对于缓存的key和value提供了多种引用类型，默认情况下，两者都是强引用类型。关于引用类型的枚举定义如下：

STRONG {
@Override
<K, V> ValueReference<K, V> referenceValue(
Segment<K, V> segment, ReferenceEntry<K, V> entry, V value, int weight) {
return (weight == 1)
? new StrongValueReference<K, V>(value)
: new WeightedStrongValueReference<K, V>(value, weight);
}

@Override
Equivalence<Object> defaultEquivalence() {
return Equivalence.equals();
}
},

SOFT {
@Override
<K, V> ValueReference<K, V> referenceValue(
Segment<K, V> segment, ReferenceEntry<K, V> entry, V value, int weight) {
return (weight == 1)
? new SoftValueReference<K, V>(segment.valueReferenceQueue, value, entry)
: new WeightedSoftValueReference<K, V>(
segment.valueReferenceQueue, value, entry, weight);
}

@Override
Equivalence<Object> defaultEquivalence() {
return Equivalence.identity();
}
},

WEAK {
@Override
<K, V> ValueReference<K, V> referenceValue(
Segment<K, V> segment, ReferenceEntry<K, V> entry, V value, int weight) {
return (weight == 1)
? new WeakValueReference<K, V>(segment.valueReferenceQueue, value, entry)
: new WeightedWeakValueReference<K, V>(
segment.valueReferenceQueue, value, entry, weight);
}

@Override
Equivalence<Object> defaultEquivalence() {
return Equivalence.identity();
}
};

值得注意的是，Equivalence<Object> defaultEquivalence()是不同的，这也正对应了上面Equivalence<Object> keyEquivalence;和Equivalence<Object> valueEquivalence;两个参数。对于强引用来说，直接使用equal进行判断对象是否相同，但对于弱引用和软引用，采用的identity方法。关于这里的的细节，会有单独章节进行讨论。本章节以STRONG进行分析。

LocalCache

这一部分结合文章开头给出的数据结构图解，就很容易理解了。
首先查看LocalCache下的成员变量：
static final int MAXIMUM_CAPACITY = 1 << 30：缓存最大容量，该数值必须是2的幂，同时小于这个最大值2^30

static final int MAX_SEGMENTS = 1 << 16：Segment数组最大容量

static final int CONTAINS_VALUE_RETRIES = 3：containsValue方法的重试次数

static final int DRAIN_THRESHOLD = 0x3F（63）：Number of cache access operations that can be buffered per segment before the cache's recency ordering information is updated. This is used to avoid lock contention by recording a memento of reads and delaying a lock acquisition until the threshold is crossed or a mutation occurs.

static final int DRAIN_MAX = 16：一次清理操作中，最大移除的entry数量

final int segmentMask：定位segment

final int segmentShift：定位segment，同时让entry分布均匀，尽量平均分布在每个segment[i]中

final Segment<K, V>[] segments：segment数组，每个元素下都是一个HashTable

final int concurrencyLevel：并发程度，用来计算segment数组的大小。segment数组的大小正决定了并发的程度

final Equivalence<Object> keyEquivalence：key比较方式

final Equivalence<Object> valueEquivalence：value比较方式

final Strength keyStrength：key引用类型

final Strength valueStrength：value引用类型

final long maxWeight：最大权重

final Weigher<K, V> weigher：计算每个entry权重的接口

final long expireAfterAccessNanos：一个entry访问后多久过期

final long expireAfterWriteNanos：一个entry写入后多久过期

final long refreshNanos：一个entry写入多久后进行刷新

final Queue<RemovalNotification<K, V>> removalNotificationQueue：移除监听器使用队列

final RemovalListener<K, V> removalListener：entry过期移除或者gc回收（弱引用和软引用）将会通知的监听器

final Ticker ticker：统计时间

final EntryFactory entryFactory：创建entry的工厂

final StatsCounter globalStatsCounter：全局缓存性能统计器（命中、未命中、put成功、失败次数等）

final CacheLoader<? super K, V> defaultLoader：默认的缓存加载器

LocalCache构造入口如下：

LocalCache(CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader)

其中，builder就是通过CacheBuilder创建的实例，这个在上面的小节中已经讲解了，下面看一下LocalCache初始化部分的代码：

LocalCache(
CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
//并发程度，根据我们传的参数和默认最大值中选取小者。
//如果没有指定该参数的情况下，CacheBuilder将其置为UNSET_INT即为-1
//getConcurrencyLevel方法获取时，如果为-1就返回默认值4
//否则返回用户传入的参数
concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
//键值的引用类型，没有指定的话，默认为强引用类型
keyStrength = builder.getKeyStrength();
valueStrength = builder.getValueStrength();
//判断相同的方法，强引用类型就是Equivalence.equals()
keyEquivalence = builder.getKeyEquivalence();
valueEquivalence = builder.getValueEquivalence();

maxWeight = builder.getMaximumWeight();
weigher = builder.getWeigher();
expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
refreshNanos = builder.getRefreshNanos();
//移除消息监听器
removalListener = builder.getRemovalListener();
//如果我们指定了移除消息监听器的话，会创建一个队列，临时保存移除的内容
removalNotificationQueue = (removalListener == NullListener.INSTANCE)
? LocalCache.<RemovalNotification<K, V>>discardingQueue()
: new ConcurrentLinkedQueue<RemovalNotification<K, V>>();

ticker = builder.getTicker(recordsTime());
//创建新的缓存内容（entry）的工厂，会根据引用类型选择对应的工厂
entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
globalStatsCounter = builder.getStatsCounterSupplier().get();
defaultLoader = loader;
//初始化缓存容量，默认为16
int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
if (evictsBySize() && !customWeigher()) {
initialCapacity = Math.min(initialCapacity, (int) 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;
//根据并发程度来计算segement数组的大小（大于等于concurrencyLevel的最小的2的幂，这里即为4）
while (segmentCount < concurrencyLevel
&& (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
++segmentShift;
segmentCount <<= 1;
}
//这里的segmentShift和segmentMask用来打散entry，让缓存内容尽量均匀分布在每个segment下
this.segmentShift = 32 - segmentShift;
segmentMask = segmentCount - 1;
//这里进行初始化segment数组，大小即为4
this.segments = newSegmentArray(segmentCount);
//每个segment的容量，总容量/segment的大小，向上取整，这里就是16/4=4
int segmentCapacity = initialCapacity / segmentCount;
if (segmentCapacity * segmentCount < initialCapacity) {
++segmentCapacity;
}
//这里计算每个Segment[i]下的table的大小
int segmentSize = 1;
//SegmentSize为小于segmentCapacity的最大的2的幂，这里为4
while (segmentSize < segmentCapacity) {
segmentSize <<= 1;
}
//初始化每个segment[i]
//注：根据权重的方法使用较少，这里走else分支
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());
}
}
}

到这里缓存就初始化完成了。
下面我们看一下Segment的定义，实现上跟ConcurrentHashMap的原理很像，因此不作详细介绍。具体可以看看ConcurrentHashMap的实现源码。

static class Segment<K, V> extends ReentrantLock {

final LocalCache<K, V> map;

/**
* The number of live elements in this segment's region.
*/
volatile int count;

/**
* The weight of the live elements in this segment's region.
*/
@GuardedBy("this")
long totalWeight;

/**
* Number of updates that alter the size of the table. This is used during bulk-read methods to
* make sure they see a consistent snapshot: If modCounts change during a traversal of segments
* loading size or checking containsValue, then we might have an inconsistent view of state
* so (usually) must retry.
*/
int modCount;

/**
* The table is expanded when its size exceeds this threshold. (The value of this field is
* always {@code (int) (capacity * 0.75)}.)
*/
int threshold;

/**
* The per-segment table.
*/
volatile AtomicReferenceArray<ReferenceEntry<K, V>> table;

/**
* The maximum weight of this segment. UNSET_INT if there is no maximum.
*/
final long maxSegmentWeight;

/**
* The key reference queue contains entries whose keys have been garbage collected, and which
* need to be cleaned up internally.
*/
final ReferenceQueue<K> keyReferenceQueue;

/**
* The value reference queue contains value references whose values have been garbage collected,
* and which need to be cleaned up internally.
*/
final ReferenceQueue<V> valueReferenceQueue;

/**
* The recency queue is used to record which entries were accessed for updating the access
* list's ordering. It is drained as a batch operation when either the DRAIN_THRESHOLD is
* crossed or a write occurs on the segment.
*/
final Queue<ReferenceEntry<K, V>> recencyQueue;

/**
* A counter of the number of reads since the last write, used to drain queues on a small
* fraction of read operations.
*/
final AtomicInteger readCount = new AtomicInteger();

/**
* A queue of elements currently in the map, ordered by write time. Elements are added to the
* tail of the queue on write.
*/
@GuardedBy("this")
final Queue<ReferenceEntry<K, V>> writeQueue;

/**
* A queue of elements currently in the map, ordered by access time. Elements are added to the
* tail of the queue on access (note that writes count as accesses).
*/
@GuardedBy("this")
final Queue<ReferenceEntry<K, V>> accessQueue;

/** Accumulates cache statistics. */
final StatsCounter statsCounter;
}

注意到其中有几个队列，keyReferenceQueue和valueReferenceQueue，在弱引用或软引用情况下gc回收的内容会放入这两个队列，accessQueue，用来进行LRU替换算法，recencyQueue记录哪些entry被访问，用于accessQueue的更新。

各种缓存的核心操作无外乎put/get/remove等。下面我们先抛开统计、LRU等，重点关注Guava Cache的put、get方法的实现。
下面是get方法的源码：

@Override
public V get(K key) throws ExecutionException {
return localCache.getOrLoad(key);
}

V getOrLoad(K key) throws ExecutionException {
return get(key, defaultLoader);
}

V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
//这里对哈希再哈希（Wang/Jenkins方法，为了进一步降低冲突）的细节暂时不讲，重点关注后面的get方法
int hash = hash(checkNotNull(key));
//根据hash找到对应的那个segment
return segmentFor(hash).get(key, hash, loader);
}

Segment<K, V> segmentFor(int hash) {
return segments[(hash >>> segmentShift) & segmentMask];
}

V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
//key和loader不能为null（空指针异常）
checkNotNull(key);
checkNotNull(loader);
try {
//count保存的是该sengment中缓存的数量，如果为0，就直接去载入
if (count != 0) { // read-volatile
// don't call getLiveEntry, which would ignore loading values
ReferenceEntry<K, V> e = getEntry(key, hash);
//e != null说明缓存中已存在
if (e != null) {
long now = map.ticker.read();
//getLiveValue在entry无效、过期、正在载入都会返回null，如果返回不为空，就是正常命中
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();
if (valueReference.isLoading()) {
//如果正在加载中，等待加载完成获取
return waitForLoadingValue(e, key, valueReference);
}
}
}
//如果不存在或者过期，就通过loader方法进行加载
return lockedGetOrLoad(key, hash, loader);
} catch (ExecutionException ee) {
Throwable cause = ee.getCause();
if (cause instanceof Error) {
throw new ExecutionError((Error) cause);
} else if (cause instanceof RuntimeException) {
throw new UncheckedExecutionException(cause);
}
throw ee;
} finally {
//清理。通常情况下，清理操作会伴随写入进行，但是如果很久不写入的话，就需要读线程进行完成
//那么这个“很久”是多久呢？还记得前面我们设置了一个参数DRAIN_THRESHOLD=63吧
//而我们的判断条件就是if ((readCount.incrementAndGet() & DRAIN_THRESHOLD) == 0)
//条件成立，才会执行清理，也就是说，连续读取64次就会执行一次清理操作
//具体是如何清理的，后面再介绍，这里仅关注核心流程
postReadCleanup();
}
}

说明：一般缓存的get方法会去查找指定的key对应的value，如果不存在就直接返回null或者抛出异常,如OSCache就是抛出一个缓存需要刷新的异常，让用户进行put操作，Guava Cache这样的处理很有意思，在get获取不到或者过期的话，会通过我们提供的load方法将entry主动加载到缓存中来。
下面是get方法的核心源码，大部分说明都在注释中：

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;
//加锁
lock();
try {
// re-read ticker once inside the lock
long now = map.ticker.read();
preWriteCleanup(now);

int newCount = this.count - 1;
//当前segment下的HashTable
AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
//这里也是为什么table的大小要为2的幂（最后index范围刚好在0-table.length()-1）
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();
// 被gc回收（在弱引用和软引用的情况下会发生）
if (value == null) {
enqueueNotification(entryKey, hash, valueReference, RemovalCause.COLLECTED);
} else if (map.isExpired(e, now)) {
// 过期
enqueueNotification(entryKey, hash, valueReference, RemovalCause.EXPIRED);
} else {
//存在并且没有过期，更新访问队列并记录命中信息，返回value
recordLockedRead(e, now);
statsCounter.recordHits(1);
// we were concurrent with loading; don't consider refresh
return value;
}

// 对于被gc回收和过期的情况，从写队列和访问队列中移除
// 因为在后面重新载入后，会再次添加到队列中
writeQueue.remove(e);
accessQueue.remove(e);
this.count = newCount; // write-volatile
}
break;
}
}

if (createNewEntry) {
//先创建一个loadingValueReference，表示正在载入
loadingValueReference = new LoadingValueReference<K, V>();

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 {
// Synchronizes on the entry to allow failing fast when a recursive load is
// detected. This may be circumvented when an entry is copied, but will fail fast most
// of the time.
synchronized (e) {
//异步加载
return loadSync(key, hash, loadingValueReference, loader);
}
} finally {
//记录未命中
statsCounter.recordMisses(1);
}
} else {
// 等待加载进来然后读取即可
return waitForLoadingValue(e, key, valueReference);
}
}

下面是异步载入的代码：

V loadSync(K key, int hash, LoadingValueReference<K, V> loadingValueReference,
CacheLoader<? super K, V> loader) throws ExecutionException {
//这里通过我们重写的load方法，根据key，将value载入
ListenableFuture<V> loadingFuture = loadingValueReference.loadFuture(key, loader);
return getAndRecordStats(key, hash, loadingValueReference, loadingFuture);
}
//等待载入，并记录载入成功或失败
V getAndRecordStats(K key, int hash, LoadingValueReference<K, V> loadingValueReference,
ListenableFuture<V> newValue) throws ExecutionException {
V value = null;
try {
value = getUninterruptibly(newValue);
if (value == null) {
throw new InvalidCacheLoadException("CacheLoader returned null for key " + key + ".");
}
//性能统计信息记录载入成功
statsCounter.recordLoadSuccess(loadingValueReference.elapsedNanos());
//这个方法才是真正的将缓存内容加载完成（当前还是loadingValueReference，表示isLoading）
storeLoadedValue(key, hash, loadingValueReference, value);
return value;
} finally {
if (value == null) {
statsCounter.recordLoadException(loadingValueReference.elapsedNanos());
removeLoadingValue(key, hash, loadingValueReference);
}
}
}

boolean storeLoadedValue(K key, int hash, LoadingValueReference<K, V> oldValueReference,
V newValue) {
lock();
try {
long now = map.ticker.read();
preWriteCleanup(now);

int newCount = this.count + 1;
if (newCount > this.threshold) { // ensure capacity
expand();
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 (ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
K entryKey = e.getKey();
if (e.getHash() == hash && entryKey != null
&& map.keyEquivalence.equivalent(key, entryKey)) {
ValueReference<K, V> valueReference = e.getValueReference();
V entryValue = valueReference.get();
// replace the old LoadingValueReference if it's live, otherwise
// perform a putIfAbsent
if (oldValueReference == valueReference
|| (entryValue == null && valueReference != UNSET)) {
++modCount;
if (oldValueReference.isActive()) {
RemovalCause cause =
(entryValue == null) ? RemovalCause.COLLECTED : RemovalCause.REPLACED;
enqueueNotification(key, hash, oldValueReference, cause);
newCount--;
}
//LoadingValueReference变成对应引用类型的ValueReference，并进行赋值
setValue(e, key, newValue, now);
//volatile写入
this.count = newCount; // write-volatile
evictEntries();
return true;
}

// the loaded value was already clobbered
valueReference = new WeightedStrongValueReference<K, V>(newValue, 0);
enqueueNotification(key, hash, valueReference, RemovalCause.REPLACED);
return false;
}
}

++modCount;
ReferenceEntry<K, V> newEntry = newEntry(key, hash, first);
setValue(newEntry, key, newValue, now);
table.set(index, newEntry);
this.count = newCount; // write-volatile
evictEntries();
return true;
} finally {
unlock();
postWriteCleanup();
}
}

至此，Guava Cache从get以及put的核心部分已经分析完了。关于其余的部分细节以及各个数据结构的具体实现，可以好好研读源码，本文主要理通总体流程，分析其实现原理。

OSCache和Guava Cache在实现上有很大不同，但二者都是非常优秀的本地缓存框架，认真学习它们的实现原理和源码，对开发是大有裨益的。我们对其进行一下简要的对比：
OSCache和Guava Cache底层都是HashTable，但是二者又是不同的。OSCache对原有HashTable进行了扩展，在get方法上是没有加锁的，而是通过其他措施进行并发安全控制，因此读性能大幅度提高；Guava Cache也是对HashTable进行了扩展，原理类似于ConcurrentHashMap，通过分离锁等实现线程安全的同时，读写性能都大大提高，尤其在写上，也是可以并发的。

OSCache在get方法时，如果缓存过期或者不存在，会抛出需要刷新的异常，用户需要通过put方法进行刷新缓存，否则会发生死锁；而Guava Cache在get的时候，会通过用户重载的load方法，自动进行加载，十分方便。