基本用法
构建
public static void initCache(LoadingCache cache) throws ExecutionException {
for(int i =1;i<=3;i++){
//连接数据源 ,如果缓存没有就读取数据源
cache.get(String.valueOf(i));
}
}
/**
* 获得当前缓存的记录
* @param cache
* @throws Exception
*/
public static void displayCache(LoadingCache cache)throws Exception{
Iterator its=cache.asMap().entrySet().iterator();
while(its.hasNext()){
System.out.println(its.next().toString());
}
}
public static void main(String[] args) throws Exception {
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
- 另一种
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
其它用法
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
//最大个数3
.maximumSize(3)
//统计
.recordStats()
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(" onRemoval key "+notification.getKey()+" 原因: "+notification.getCause());
}
})
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
System.out.println(cache.size());
Object o1 = cache.getIfPresent("1");
System.out.println("========================"+o1);
displayCache(cache);
Object o = get("4", cache);
System.out.println("========================");
displayCache(cache);
System.out.println(cache.stats());
删除1
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
//最大个数3
.maximumSize(3)
.expireAfterAccess(3, TimeUnit.SECONDS)
//统计
.recordStats()
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(" onRemoval key "+notification.getKey()+" 原因: "+notification.getCause());
}
})
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
//显示缓存数据
displayCache(cache);
Thread.sleep(1000);
//访问1
cache.getIfPresent("1");
//歇了2.1秒
Thread.sleep(2100);
System.out.println("==================================");
displayCache(cache);
删除2
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
//最大个数3
.maximumSize(3)
.expireAfterWrite(3, TimeUnit.SECONDS)
//统计
.recordStats()
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(" onRemoval key "+notification.getKey()+" 原因: "+notification.getCause());
}
})
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
//显示缓存数据
displayCache(cache);
Thread.sleep(1000);
//访问1
cache.getIfPresent("1");
//歇了2.1秒
Thread.sleep(2100);
System.out.println("==================================");
displayCache(cache);
弱key
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
//最大个数3
.maximumSize(3)
.weakValues()
//统计
.recordStats()
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(" onRemoval key "+notification.getKey()+" 原因: "+notification.getCause());
}
})
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
//显示缓存数据
displayCache(cache);
Object v = new Object();
cache.put("1",v);
v = new Object();
System.gc();
System.out.println("=============");;
displayCache(cache);
删除指定
//CacheLoader方式
LoadingCache<String,Object> cache=CacheBuilder.newBuilder()
//最大个数3
.maximumSize(3)
//统计
.recordStats()
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(" onRemoval key "+notification.getKey()+" 原因: "+notification.getCause());
}
})
.build(new CacheLoader<String, Object>() {
@Override
public Object load(String key) throws Exception {
return Constants.hm.get(key);
}
});
//初始化
initCache(cache);
//显示缓存数据
displayCache(cache);
//删除所有
//cache.invalidateAll();
//删除指定
// cache.invalidate("1");
cache.invalidateAll(Arrays.asList("1","2"));
System.out.println("=============");
displayCache(cache);
GuavaCache核心原理之数据结构
Guava Cache的数据结构跟ConcurrentHashMap类似,但也不完全一样。最基本的区别是
ConcurrentMap会一直保存所有添加的元素,直到显式地移除。
相对地,Guava Cache为了限制内存占用,通常都设定为自动回收元素。其数据结构图如下
- LocalCache为Guava Cache的核心类,包含一个Segment数组组成
- Segement数组的长度决定了cache的并发数
- 每一个Segment使用了单独的锁,其实每个Segment继承了ReentrantLock,对Segment的写操作需要先拿到锁
- 每个Segment由一个table和5个队列组成
5个队列
- ReferenceQueue keyReferenceQueue : 已经被GC,需要内部清理的键引用队列
- ReferenceQueue valueReferenceQueue : 已经被GC,需要内部清理的值引用队列
- ConcurrentlinkedQueue<ReferenceEntry<k,v>> recencyQueue : LRU队列,当segment上达到
临界值发生写操作时该队列会移除数据 - Queue<ReferenceEntry<K, V>> writeQueue:写队列,按照写入时间进行排序的元素队列,写入一个元素时会把它加入到队列尾部
- Queue<ReferenceEntry<K, V>> accessQueue:访问队列,按照访问时间进行排序的元素队列,访问(包括写入)一个元素时会把它加入到队列尾部
1个table:
AtomicReferenceArray<ReferenceEntry<K, V>> table:AtomicReferenceArray可以用原子方式
更新其元素的对象引用数组
ReferenceEntry<k,v>
ReferenceEntry是Guava Cache中对一个键值对节点的抽象,每个ReferenceEntry数组项都是一条ReferenceEntry链。并且一个ReferenceEntry包含key、hash、valueReference、next字段(单链)
Guava Cache使用ReferenceEntry接口来封装一个键值对,而用ValueReference来封装Value值
GuavaCache核心原理之回收机制
Guava Cache提供了三种基本的缓存回收方式:
- 基于容量回收
在缓存项的数目达到限定值之前,采用LRU的回收方式 - 定时回收
expireAfterAccess:缓存项在给定时间内没有被读/写访问,则回收。回收顺序和基于大小回收一样(LRU)
expireAfterWrite:缓存项在给定时间内没有被写访问(创建或覆盖),则回收 - 基于引用回收
通过使用弱引用的键、或弱引用的值、或软引用的值,Guava Cache可以垃圾回收
除了以上三种还有主动删除,采用命令,
GuavaCache构建的缓存不会"自动"执行清理和回收工作,也不会在某个缓存项过期后马上清理,也没有诸如此类的清理机制。
GuavaCache是在每次进行缓存操作的时候,惰性删除 如get()或者put()的时候,判断缓存是否过期
GuavaCache核心原理之Segment定位
通过key做hash定位到所在的Segment
通过位运算找首地址的偏移量 SegmentCount>=并发数且为2的n次方
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
// 注意,key不可为空
int hash = hash(checkNotNull(key));
// 通过hash定位到segment数组的某个Segment元素,然后调用其get方法
return segmentFor(hash).get(key, hash, loader);
}
再找到segment中的Entry链数组,通过key的hash定位到某个Entry节点
V get(K key, int hash, CacheLoader<? super K, V> loader) throws
ExecutionException {
checkNotNull(key);
checkNotNull(loader);
try {
if (count != 0) { // read-volatile
// 内部也是通过找Entry链数组定位到某个Entry节点
ReferenceEntry<K, V> e = getEntry(key, hash);
......
GuavaCache 并发设置
GuavaCache通过设置 concurrencyLevel 使得缓存支持并发的写入和读取
LoadingCache<String,Object> cache = CacheBuilder.newBuilder()
// 最大3个 同时支持CPU核数线程写缓存
.maximumSize(3)
.concurrencyLevel(Runtime.getRuntime().availableProcessors())
.build();
concurrencyLevel=Segment数组的长度
默认长度4
同ConcurrentHashMap类似Guava cache的并发也是通过分离锁实现
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
int hash = this.hash(Preconditions.checkNotNull(key));
//通过hash值确定该key位于哪一个segment上,并获取该segment
return this.segmentFor(hash).get(key, hash, loader);
}
LoadingCache采用了类似ConcurrentHashMap的方式,将映射表分为多个segment。segment之间可以并发访问,这样可以大大提高并发的效率,使得并发冲突的可能性降低了。
更新锁定
GuavaCache提供了一个refreshAfterWrite定时刷新数据的配置项
如果经过一定时间没有更新或覆盖,则会在下一次获取该值的时候,会在后台异步去刷新缓存刷新时只有一个请求回源取数据,其他请求会阻塞(block)在一个固定时间段,如果在该时间段内没有获得新值则返回旧值。
LoadingCache<String,Object> cache = CacheBuilder.newBuilder()
// 最大3个 同时支持CPU核数线程写缓存
.maximumSize(3).concurrencyLevel(Runtime.getRuntime().availableProcessors()).
//3秒内阻塞会返回旧数据
refreshAfterWrite(3,TimeUnit.SECONDS).build();
动态加载
动态加载行为发生在获取不到数据或者是数据已经过期的时间点,Guava动态加载使用回调模式
用户自定义加载方式,然后Guava cache在需要加载新数据时会回调用户的自定义加载方式
segmentFor(hash).get(key, hash, loader)
loader即为用户自定义的数据加载方式,当某一线程get不到数据会去回调该自定义加载方式去加载数
据
自定义LRU算法
public class LRUcache<k, v> extends LinkedHashMap<k, v> {
private final int limit;
public LRUcache(int limit) {
//初始化 accessOrder : true 改变尾结点
super(16, 0.75f, true);
this.limit = limit;
}
//是否删除最老的数据
@Override
protected boolean removeEldestEntry(Map.Entry<k, v> eldest) {
return size() > limit;
}
}
//
public class LinkedHashLRUcache<k,v> {
/**
* LinkedHashMap(自身实现了LRU算法)
* 有序
* 每次访问一个元素,都会加到尾部
*/
int limit;
LRUcache<k, v> lruCache;
public LinkedHashLRUcache(int limit) {
this.limit = limit;
this.lruCache = new LRUcache(limit);
}
public void put(k key, v value) {
this.lruCache.put(key, value);
}
public v get(k key) {
return this.lruCache.get(key);
}
public static void main(String[] args) {
LinkedHashLRUcache lru = new LinkedHashLRUcache(3);
lru.put(1, "zhangfei1");
lru.put(2, "zhangfei2");
lru.put(3, "zhangfei3");
lru.get(1);
lru.put(4, "zhangfei4");
for (Object o : lru.lruCache.values()) {
System.out.println(o.toString());
}
}
}
GuavaCache会oom(内存溢出)吗
会,当我们设置缓存永不过期(或者很长),缓存的对象不限个数(或者很大)时,比如:
Cache<String, String> cache = CacheBuilder.newBuilder()
.expireAfterWrite(100000, TimeUnit.SECONDS)
.build();
不断向GuavaCache加入大字符串,最终将会oom
解决方案:缓存时间设置相对小些,使用弱引用方式存储对象
Cache<String, String> cache = CacheBuilder.newBuilder()
.expireAfterWrite(1, TimeUnit.SECONDS)
.weakValues().build();
GuavaCache缓存到期就会立即清除吗
不是的,GuavaCache是在每次进行缓存操作的时候,如get()或者put()的时候,判断缓存是否过期
void evictEntries(ReferenceEntry<K, V> e) {
drainRecencyQueue();
while ((e = writeQueue.peek()) != null && map.isExpired(e, now)) {
if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
throw new AssertionError();
}
} w
hile ((e = accessQueue.peek()) != null && map.isExpired(e, now)) {
if (!removeEntry(e, e.getHash(), RemovalCause.EXPIRED)) {
throw new AssertionError();
}
}
}
一个如果一个对象放入缓存以后,不在有任何缓存操作(包括对缓存其他key的操作),那么该缓存不会主动过期的
GuavaCache如何找出最久未使用的数据
用accessQueue,这个队列是按照LRU的顺序存放的缓存对象(ReferenceEntry)的。会把访问过的对象放到队列的最后。
并且可以很方便的更新和删除链表中的节点,因为每次访问的时候都可能需要更新该链表,放入到链表
的尾部。
这样,每次从access中拿出的头节点就是最久未使用的。
对应的writeQueue用来保存最久未更新的缓存队列,实现方式和accessQueue一样。
结构
- CacheBuilder:类,缓存构建器。构建缓存的入口,指定缓存配置参数并初始化本地缓存。
CacheBuilder在build方法中,会把前面设置的参数,全部传递给LocalCache,它自己实际不参与任何计算 - CacheLoader:抽象类。用于从数据源加载数据,定义load、reload、loadAll等操作
- Cache:接口,定义get、put、invalidate等操作,这里只有缓存增删改的操作,没有数据加载的操作
- LoadingCache:接口,继承自Cache。定义get、getUnchecked、getAll等操作,这些操作都会从数据源load数据
- LocalCache:类。整个guava cache的核心类,包含了guava cache的数据结构以及基本的缓存的操作方法
- LocalManualCache:LocalCache内部静态类,实现Cache接口。其内部的增删改缓存操作全部调用成员变量localCache(LocalCache类型)的相应方法
- LocalLoadingCache:LocalCache内部静态类,继承自LocalManualCache类,实现
- LoadingCache接口。其所有操作也是调用成员变量localCache(LocalCache类型)的相应方法
源码之LocalCache
LoadingCache这些类表示获取Cache的方式,可以有多种方式,但是它们的方法最终调用到LocalCache的方法,LocalCache是Guava Cache的核心类
@GwtCompatible(emulated = true)
class LocalCache<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {
LocalCache为Guava Cache的核心类 LocalCache的数据结构与ConcurrentHashMap很相似,都由多个segment组成,且各segment相对独立,互不影响,所以能支持并行操作
//Map的数组
final Segment<K, V>[] segments;
//并发量,即segments数组的大小
final int concurrencyLevel;
...
//访问后的过期时间,设置了expireAfterAccess就有
final long expireAfterAccessNanos;
//写入后的过期时间,设置了expireAfterWrite就有
final long expireAfterWriteNa就有nos;
//刷新时间,设置了refreshAfterWrite就有
final long refreshNanos;
//removal的事件队列,缓存过期后先放到该队列
final Queue<RemovalNotification<K, V>> removalNotificationQueue;
//设置的removalListener
final RemovalListener<K, V> removalListener;
....
源码之 Segment
每个segment由一个table和若干队列组成。缓存数据存储在table中,其类型为AtomicReferenceArray
static class Segment<K, V> extends ReentrantLock {
/**
* segments 维护一个entry列表的table,确保一致性状态。所以可以不加锁去读。节点的
next field是不可修改的final,因为所有list的增加操作
*/
final LocalCache<K, V> map;
/**
* 该segment区域内所有存活的元素个数
*/
volatile int count;
/**
* 改变table大小size的更新次数。这个在批量读取方法期间保证它们可以看到一致性的快照:
* 如果modCount在我们遍历段加载大小或者核对containsValue期间被改变了,然后我们会看
到一个不一致的状态视图,以至于必须去重试。
* count+modCount 保证内存一致性
* *
感觉这里有点像是版本控制,比如数据库里的version字段来控制数据一致性
*/
int modCount;
/**
* 每个段表,使用乐观锁的Array来保存entry The per-segment table.
*/
volatile AtomicReferenceArray<ReferenceEntry<K, V>> table; // 这里和
concurrentHashMap不一致,原因是这边元素是引用,直接使用不会线程安全
/**
* A queue of elements currently in the map, ordered by write time.
Elements are added to the tail of the queue
* on write.
*/
@GuardedBy("Segment.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("Segment.this")
final Queue<ReferenceEntry<K, V>> accessQueue;
}
源码之 ReferenceEntry
@GwtIncompatible
interface ReferenceEntry<K, V> {
/** Returns the value reference from this entry. */
ValueReference<K, V> getValueReference();
/** Sets the value reference for this entry. */
void setValueReference(ValueReference<K, V> valueReference);
/** Returns the next entry in the chain. */
@Nullable
ReferenceEntry<K, V> getNext();
/** Returns the entry's hash. */
int getHash();
/** Returns the key for this entry. */
@Nullable
K getKey();
/*
* Used by entries that use access order. Access entries are maintained in a doubly-linked list.
* New entries are added at the tail of the list at write time; stale entries are expired from
* the head of the list.
*/
/** Returns the time that this entry was last accessed, in ns. */
@SuppressWarnings("GoodTime")
long getAccessTime();
/** Sets the entry access time in ns. */
@SuppressWarnings("GoodTime") // b/122668874
void setAccessTime(long time);
/** Returns the next entry in the access queue. */
ReferenceEntry<K, V> getNextInAccessQueue();
/** Sets the next entry in the access queue. */
void setNextInAccessQueue(ReferenceEntry<K, V> next);
/** Returns the previous entry in the access queue. */
ReferenceEntry<K, V> getPreviousInAccessQueue();
/** Sets the previous entry in the access queue. */
void setPreviousInAccessQueue(ReferenceEntry<K, V> previous);
/*
* Implemented by entries that use write order. Write entries are maintained in a doubly-linked
* list. New entries are added at the tail of the list at write time and stale entries are
* expired from the head of the list.
*/
@SuppressWarnings("GoodTime")
/** Returns the time that this entry was last written, in ns. */
long getWriteTime();
/** Sets the entry write time in ns. */
@SuppressWarnings("GoodTime") // b/122668874
void setWriteTime(long time);
/** Returns the next entry in the write queue. */
ReferenceEntry<K, V> getNextInWriteQueue();
/** Sets the next entry in the write queue. */
void setNextInWriteQueue(ReferenceEntry<K, V> next);
/** Returns the previous entry in the write queue. */
ReferenceEntry<K, V> getPreviousInWriteQueue();
/** Sets the previous entry in the write queue. */
void setPreviousInWriteQueue(ReferenceEntry<K, V> previous);
}
源码之CacheBuilder
缓存构建器。构建缓存的入口,指定缓存配置参数并初始化本地缓存。
主要采用builder的模式,CacheBuilder的每一个方法都返回这个CacheBuilder知道build方法的调用。
注意build方法有重载,带有参数的为构建一个具有数据加载功能的缓存,不带参数的构建一个没有数
据加载功能的缓存
build方法会创建LocalCache
public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
CacheLoader<? super K1, V1> loader) {
checkWeightWithWeigher();
return new LocalCache.LocalLoadingCache<>(this, loader);
}
源码剖析之Put流程
1、上锁
2、清除队列元素
清理的是keyReferenceQueue和valueReferenceQueue这两个队列,这两个队列是引用队列
如果发现key或者value被GC了,那么会在put的时候触发清理
3、setvalue方法了,它做的是将value写入Entry
@Override
public V put(K key, V value) {
checkNotNull(key);
checkNotNull(value);
int hash = hash(key);
return segmentFor(hash).put(key, hash, value, false);
}
- segmentFor
Segment<K, V> segmentFor(int hash) {
// TODO(fry): Lazily create segments?
return segments[(hash >>> segmentShift) & segmentMask];
}
- put 方法
@Nullable
V put(K key, int hash, V value, boolean onlyIfAbsent) {
//保证线程安全加锁
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;
}
//获取当前Entry中的HashTable的Entry数组
AtomicReferenceArray<ReferenceEntry<K, V>> table = this.table;
///定位 hash
int index = hash & (table.length() - 1);
获取第一个元素
ReferenceEntry<K, V> first = table.get(index);
遍历整个Entry链表判断是否存在
// Look for an existing entry.
for (ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
K entryKey = e.getKey();
//判断hash,Value是否是同一个
if (e.getHash() == hash&& entryKey != null&& map.keyEquivalence.equivalent(key, entryKey)) {
// We found an existing entry.
//如果找到相应的元素
ValueReference<K, V> valueReference = e.getValueReference();
//获取所有的值 //获取value
V entryValue = valueReference.get();
//判断是否为空
if (entryValue == null) {
//如果entry的value为null,可能被GC掉了
++modCount;
if (valueReference.isActive()) {
//减小锁时间的开销
enqueueNotification(
key, hash, entryValue, valueReference.getWeight(), RemovalCause.COLLECTED);
//利用原来的key并且刷新value
//存储数据,并且将新增加的元素写入两个队列中,一个Write队列、一个Access队列
setValue(e, key, value, now);
newCount = this.count; // count remains unchanged
} else {
//存储数据,并且将新增加的元素写入两个队列
setValue(e, key, value, now);
newCount = this.count + 1;
}
// write-volatile,保证内存可见性
this.count = newCount; // write-volatile
//淘汰缓存
evictEntries(e);
return null;
} else if (onlyIfAbsent) {
//原来的Entry中包含指定key的元素,所以读取一次,读取操作需要更新Access队列
// Mimic
// "if (!map.containsKey(key)) ...
// else return map.get(key);
recordLockedRead(e, now);
return entryValue;
} else {
// clobber existing entry, count remains unchanged
++modCount;
enqueueNotification(
key, hash, entryValue, valueReference.getWeight(), RemovalCause.REPLACED);
//存储数据,并且将新增加的元素写入两个队列中
setValue(e, key, value, now);
//数据的淘汰
evictEntries(e);
return entryValue;
}
}
}
// Create a new entry.
++modCount;
//如果目标的entry不存在,那么新建entry
ReferenceEntry<K, V> newEntry = newEntry(key, hash, first);
setValue(newEntry, key, value, now);
table.set(index, newEntry);
newCount = this.count + 1;
this.count = newCount; // write-volatile
evictEntries(newEntry);
return null;
} finally {
//解锁
unlock();
//处理刚刚的remove Cause
postWriteCleanup();
}
}
源码剖析之Get流程
- 获取对象引用(引用可能是非alive的,比如是需要失效的、比如是loading的);
- 判断对象引用是否是alive的(如果entry是非法的、部分回收的、loading状态、需要失效的,则认为不是alive)。
- 如果对象是alive的,如果设置refresh,则异步刷新查询value,然后等待返回最新value。
- 针对不是alive的,但却是在loading的,等待loading完成(阻塞等待)。
- 这里如果value还没有拿到,则查询loader方法获取对应的值(阻塞获取)。
// LoadingCache methods
//local cache的代理
V get(K key, CacheLoader<? super K, V> loader) throws ExecutionException {
int hash = hash(checkNotNull(key));
return segmentFor(hash).get(key, hash, loader);
}
V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {
//hash——>rehash
checkNotNull(key);
checkNotNull(loader);
try {
if (count != 0) { // read-volatile
// don't call getLiveEntry, which would ignore loading values
ReferenceEntry<K, V> e = getEntry(key, hash);
if (e != null) {
long now = map.ticker.read();
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);
}
}
}
// 如果取不到值,那么进行统一的加锁get
//加锁去数据源加载数据到缓存中
// 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) {
throw new ExecutionError((Error) cause);
} else if (cause instanceof RuntimeException) {
throw new UncheckedExecutionException(cause);
}
throw ee;
} finally {
每次Put和get之后都要进行一次Clean
postReadCleanup();
}
}
源码剖析之过期重载
数据过期不会自动重载,而是通过get操作时执行过期重载。具体就是CacheBuilder构造的LocalLoadingCache
static class 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) {
throw new 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);
}
@Override
public final V apply(K key) {
return getUnchecked(key);
}
// Serialization Support
private static final long serialVersionUID = 1;
@Override
Object writeReplace() {
return new LoadingSerializationProxy<>(localCache);
}
}