本地缓存

面试经常会被问到如何解决缓存击穿问题，今天就来带你弄懂他！平时业务中也会经常使用到本地缓存，公司里使用比较多的本地缓存 loadingcache,其背后的架构就是Guava cache，Guava Cache 是一个全内存的本地缓存实现，它提供了线程安全的实现机制。整体上来说Guava Cache 是本地缓存的不二之选。

适用场景

适合少量热点数据缓存（受限于内存大小），解决缓存击穿问题，可以使用LRU作为淘汰缓存策略。
愿意以空间换时间，缓存数据到本地内存（没有网络IO，速度快）
允许在重新load前读到的是脏数据（对同一数据一直访问, 且间隔小于失效时间, 则不会去load数据）
可以监听Entry清除状态
支持缓存命中情况统计

2. 使用方法

2.1 使用方式

<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>24.1-jre</version>
</dependency>

	private final LoadingCache<Long, Entity> entityCache = CacheBuilder.newBuilder()// 缓存池大小，在缓存数量到达该大小时， 开始回收旧的数据.maximumSize(10000)// 设置时间10s对象没有被读/写访问则对象从内存中删除.expireAfterAccess(10, TimeUnit.SECONDS)// 设置缓存在写入之后 设定时间10s后失效.expireAfterWrite(10, TimeUnit.SECONDS)// 定时刷新，设置时间5s后，当有访问时会重新执行load方法重新加载.refreshAfterWrite(5, TimeUnit.SECONDS)// 移除监听器,缓存项被移除时会触发.removalListener(new RemovalListener() {@Overridepublic void onRemoval(RemovalNotification rn) {// 处理缓存键不存在缓存值时的**移除**处理逻辑log.error(rn.getKey() + "remove");}})// 处理缓存键对应的缓存值不存在时的处理逻辑.build(new CacheLoader<Long, Entity>() {@Overridepublic Entity load(Long id) {return EntityService.getById(id);}});public Entity getEntity(Long id) {Entity entity = entityCache.get(id);}public ImmutableMap<Long, Entity> getAll(List<Long> ids) throws ExecutionException {return cache.getAll(ids);}

2.2 常用参数

参数	说明	注意事项
maximumSize	缓存的k-v最大数据，当总缓存的数据量达到这个值时，就会淘汰它认为不太用的一份数据，会使用LRU策略进行回收
expireAfterAccess	缓存项在给定时间内没有被读/写访问，则回收，这个策略主要是为了淘汰长时间不被访问的数据	数据过期不是立即淘汰，而是有数据访问时才会触发
expireAfterWrite	缓存项在给定时间内没有被写访问(创建或覆盖)，则回收, 防止旧数据被缓存过久	同上
refreshAfterWrite	缓存项在给定时间内没有被写访问(创建或覆盖)，则刷新	同上
recordStats	开启Cache的状态统计(默认是开启的)	可能会影响到性能

2.3 显示清除

单个清除：Cache.invalidate(key)
批量清除：Cache.invalidate(keys)
清除所有：Cache.invalidateAll()

3. LoadingCache解析

3.1 数据结构

底层数据结构是一个K.V的存储结构，这个图我想应很明显了，这分明就就是ConcurrentHashMap的结构，底层是一个segment数组，链表的节点和ConcurrentHashMap不太一样，是一个每一个segment是一个节点为ReferenceEntry<K, V>数组，segment继承了ReentrantLock,缩小了锁的力度，体现了分段式锁的思想。

3.2 Get方法

  V get(K key, int hash, CacheLoader<? super K, V> loader) throws ExecutionException {try {if (count != 0) { // read-volatileReferenceEntry<K, V> e = getEntry(key, hash);if (e != null) {long now = map.ticker.read();//检查entry是否符合expireAfterAccess淘汰策略V value = getLiveValue(e, now);// value是有效的 则返回if (value != null) {// 记录该值的最近访问时间recordRead(e, now);statsCounter.recordHits(1);// 内部实现了定时刷新，若未开启refreshAfterWrite则直接返回valuereturn scheduleRefresh(e, key, hash, value, now, loader);}ValueReference<K, V> valueReference = e.getValueReference();// 如果有别的线程已经在load value，则等到其他线程完成后再取结果if (valueReference.isLoading()) {return waitForLoadingValue(e, key, valueReference);}}}// 如果没拿到有效的value，则执行加载逻辑;return lockedGetOrLoad(key, hash, loader);} catch (ExecutionException ee) {...} finally {postReadCleanup();}}

先获取未过期的值（指内存中已经存在的，未符合expireAfterAccess淘汰策略），recordRead方法则是记录该值的最近访问时间，然后判断执行scheduleRefresh方法。

这个方法里先是判断是否设置了refreshAfterWrite属性，并判断当前时间是否符合刷新策略。符合则调用refresh进行刷新操作

3.3 load方法

@GwtCompatible(emulated = true)
public abstract class CacheLoader<K, V> {public abstract V load(K key) throws Exception;}

key对应的value不存在(或已过期)会触发load方法。

load方法是同步的，对于同一个key，多次请求只会触发一次加载。

在Thread1进行load加载完成之前，这些请求线程都会被hang等待。

3.4 reload方法

//  Guava的默认实现是同步的
public ListenableFuture<V> reload(K key, V oldValue) throws Exception {checkNotNull(key);checkNotNull(oldValue);return Futures.immediateFuture(load(key));
}

当cache中有值，但需要刷新该值的时候会触发reload方法。
LoadingCache的所有更新操作都是依靠读写方法触发的，因为其内部没有时钟或者定时任务。比如上一次写之后超过了refresh设置的更新时间，但之后没有cache的访问了，那么下次get的时候才会触发refresh。
对于同一个key，多次请求只会有一个线程触发reload，其他请求线程直接返回旧值。

3.5 CacheLoader

同步模式，会阻塞用户请求线程。

new CacheLoader<Long, Entity>() {@Overridepublic Entity load(Long entityId) {return EntityService.getById(entityId);}}

3.6 AyncReloadCacheLoader

根据Guava的API实现的异步CacheLoader，refresh操作不堵塞任何一个用户请求线程。

相对于Guava中默认实现的reload，只减少了“一个”线程的阻塞。

 
/*** 这个类只是改写了reload方法，配合refreshAfterWrite异步刷新* 避免因为使用expireAfterWrite造成缓存miss时请求线程回流影响用户请求* <p>* 代价就是一个额外的线程调度更新** @author w.vela*/
public abstract class AsyncReloadCacheLoader<K, V> extends CacheLoader<K, V> {/*** <WARNING> 请务必要覆盖这个名字，不然有人会不开心的……*/protected String statsName() {return "unknown_async_cache_reloader";}@Overridepublic ListenableFuture<V> reload(K key, V oldValue) throws Exception {ListenableFutureTask<V> task = create(() -> load(key));ExecutorHolder.execute(statsName(), task::run);return task;}
}

此类实现不推荐使用，存在一些问题:

共用一个全局线程池，线程池不为使用者所感知，不同使用方可能相互影响；

集中大量发生reload是出现频繁线程创建和销毁。

推荐替代方式:

直接使用CacheLoader，override reload方法，提供自己的异步实现。异步实现可以使用支持异步调用的API(如直接使用grpc异步)

如果没有异步调用API可以自己提供一个线程池用来做异步化。

3.7 BatchReloadCacheLoader

如果有大量集中refresh的情况，可以使用BatchReloadCacheLoader 批量处理

相比于AyncReloadCacheReloader，优点在于：使用 BufferTrigger(本地归并消费)将单个 cache refresh 操作聚合成为批量 refresh，减少线程上下文切换，提升效率。BufferTrigger中会有一个额外线程去真正执行load操作，所以不会堵塞用户请求线程。

private final LoadingCache<Long, Entity> entityCache = KsCacheBuilder.newBuilder().maximumSize(10000).expireAfterAccess(5, TimeUnit.SECONDS).enablePerf(perfName) .buildBatchReload(new CacheLoader<Long, Entity>() {@Overridepublic Entity load(Long id) {return EntityService.getById(id);}});

com.kuaishou.framework.concurrent.BatchReloadCacheLoader

    private void doBatchReload(Queue<ReloadTask<K, V>> tasks) {Stopwatch stopwatch = Stopwatch.createStarted();Multimap<K, SettableFuture<V>> futureMap = tasks.stream().collect(toMultimap(ReloadTask::getKey, ReloadTask::getFuture, ArrayListMultimap::create));try {Map<K, V> result = loadAll(futureMap.keySet());futureMap.forEach((key, future) -> future.set(result.get(key)));} catch (UnsupportedLoadingOperationException e) {futureMap.forEach((key, future) -> {try {future.set(load(key));} catch (Throwable e2) {future.setException(e2);rateLogger.warn("cache reload fail, biz:{}", bizName, e);}});} catch (Throwable e) {tasks.forEach(task -> task.getFuture().setException(e));rateLogger.warn("cache reload fail, biz:{}", bizName, e);} finally {perf("batchReload", stopwatch.elapsed());}}