Guava缓存实战及使用场景

摘要：本文是Google guava 第一件，本文先介绍了为什么使用Guava Cache缓存，然后讲解了使用方法及底层数据结构，结合实际业务，讲解使用guava过程中踩过的坑，最后讲解了guava可以优化的方向

文章目录

Guava缓存实战及使用场景
- 1 为什么使用本地缓存
- - 1.1 适用场景
- 2 如何使用Guava缓存(缓存容量/超时时间/移除监听器/缓存加载器)
- - 2.1 LoadingCache demo1
  - 2.2 几个重要的组件
  - 2.3 guava常用接口
  - 2.4 guava cache 解析 20201118补充
  - - 2.4.1 evict清除策略操作
    - 2.4.2 put操作
    - 2.4.3 Segment带CacheLoader的get操作
- 3 公司哪些业务中使用了guava缓存？
- - 3.1 禅道链接
  - 3.2 相关demo
  - 3.3、guava踩坑
  - 3.3.1、使用guava cache时避免使用weakkeys
  - 3.3.2、使用guava cache时避免笛卡尔积
  - 3.3.3、使用guava cache注意事项
  - 3.3.4、使用guava cache时异常捕获
  - 3.3.5、使用guava cache时避免入参为空
- 4 优化方向
- 5、如何清理本地缓存 20210128补充
- - 5.1、如果是手动清理
  - 5.2、如果有多台机器，欲自动清理缓存
- 6、caffeine缓存 20210128补充

1 为什么使用本地缓存

在多线程高并发场景中往往是离不开cache的，需要根据不同的应用场景来需要选择不同的cache，比如分布式缓存如Redis、memcached，还有本地（进程内）缓存如ehcache、GuavaCache。
相比IO操作，速度快，效率高；
相比Redis，Redis是一种优秀的分布式缓存实现，受限于网卡等原因，远水救不了近火。

1.1 适用场景

愿意消耗一些内存空间来提升速度
预料到某些键会被多次查询
缓存中存放的数据总量不会超出内存容量
如果你的场景符合上述的每一条，Guava Cache就适合

2 如何使用Guava缓存(缓存容量/超时时间/移除监听器/缓存加载器)

2.1 LoadingCache demo1

导入 Maven 引用

<dependency>  <groupId>com.google.guava</groupId>  <artifactId>guava</artifactId><version>19.0</version>
</dependency>

Cache初始化，类似于函数式编程的写法，可自行设置各类参数

private final LoadingCache<Long, BackCategory> backCategoryCache = CacheBuilder.newBuilder()  //设置cache的初始大小为10，要合理设置该值  .initialCapacity(10)  //设置并发数为5，即同一时间最多只能有5个线程往cache执行写入操作  .concurrencyLevel(5) //最大key个数.maximumSize(100)//移除监听器.removalListener(removalListener)//设置cache中的数据在写入之后的存活时间为10秒  .expireAfterWrite(10, TimeUnit.SECONDS)  //构建cache实例  .build(new CacheLoader<Long, BackCategory>() {@Overridepublic BackCategory load(Long categoryId) throws Exception {Response<BackCategory> rBackCategory = backCategoryReadService.findById(categoryId);if (!rBackCategory.isSuccess()) {log.warn("failed to find back category(id={}), error code:{}",categoryId, rBackCategory.getError());throw new ServiceException("find back category fail,code: " + rBackCategory.getError());}return rBackCategory.getResult();}
}); RemovalListener<String, String> removalListener = new RemovalListener<String, String>() {public void onRemoval(RemovalNotification<categoryId, BackCategory> removal) {System.out.println("[" + removal.getKey() + ":" + removal.getValue() + removal.getCause() +  "] is evicted!");}
};

2.2 几个重要的组件

1、CacheBuilder 缓存构建器。构建缓存的入口，指定缓存配置参数并初始化本地缓存。采用构建者模式提供了设置好各种参数的缓存对象。
2、LocalCache数据结构。缓存核心类LocalCache数据结构与ConcurrentHashMap很相似，由多个segment组成，且各segment相对独立，互不影响，所以能支持并行操作，每个segment由一个table和若干队列组成。缓存数据存储在table中，其类型为AtomicReferenceArray。

序号	数据结构	特点	详解
1	Segment<K, V>[] segments	Segment继承于ReetrantLock，减小锁粒度，提高并发效率
2	AtomicReferenceArray<ReferenceEntry<K, V>> table	类似于HasmMap中的table一样，相当于entry的容器
3	ReferenceEntry<K, V> referenceEntry	基于引用的Entry,其实现类有弱引用Entry,强引用Entry等	Cache由多个Segment组成，而每个Segment包含一个ReferenceEntry数组，每个ReferenceEntry数组项都是一条ReferenceEntry链，且一个ReferenceEntry包含key、hash、valueReference、next字段。除了在ReferenceEntry数组项中组成的链，在一个Segment中，所有ReferenceEntry还组成access链（accessQueue）和write链（writeQueue）（后面会介绍链的作用）。ReferenceEntry可以是强引用类型的key，也可以WeakReference类型的key，为了减少内存使用量，还可以根据是否配置了expireAfterWrite、expireAfterAccess、maximumSize来决定是否需要write链和access链确定要创建的具体Reference：StrongEntry、StrongWriteEntry、StrongAccessEntry、StrongWriteAccessEntry等
4	ReferenceQueue keyReferenceQueue	已经被GC，需要内部清理的键引用队列
5	ReferenceQueue valueReferenceQueue	已经被GC，需要内部清理的值引用队列	因为Cache支持强引用的Value、SoftReference Value以及WeakReference Value，因而它对应三个实现类：StrongValueReference、SoftValueReference、WeakValueReference。为了支持动态加载机制，它还有一个LoadingValueReference，在需要动态加载一个key的值时，先把该值封装在LoadingValueReference中，以表达该key对应的值已经在加载了，如果其他线程也要查询该key对应的值，就能得到该引用，并且等待改值加载完成，从而保证该值只被加载一次，在该值加载完成后，将LoadingValueReference替换成其他ValueReference类型。ValueReference对象中会保留对ReferenceEntry的引用，这是因为在Value因为WeakReference、SoftReference被回收时，需要使用其key将对应的项从Segment的table中移除
6	Queue<ReferenceEntry<K, V>> recencyQueue	记录升级可访问列表清单时的entries,当segment上达到临界值或发生写操作时该队列会被清空
7	Queue<ReferenceEntry<K, V>> writeQueue	按照写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部	为了实现最近最少使用算法，Guava Cache在Segment中添加了两条链：write链（writeQueue）和access链（accessQueue），这两条链都是一个双向链表，通过ReferenceEntry中的previousInWriteQueue、nextInWriteQueue和previousInAccessQueue、nextInAccessQueue链接而成，但是以Queue的形式表达。WriteQueue和AccessQueue都是自定义了offer、add（直接调用offer）、remove、poll等操作的逻辑，对offer（add）操作，如果是新加的节点，则直接加入到该链的结尾，如果是已存在的节点，则将该节点链接的链尾；对remove操作，直接从该链中移除该节点；对poll操作，将头节点的下一个节点移除，并返回
8	Queue<ReferenceEntry<K, V>> accessQueue	按照访问时间进行排序的元素队列，访问(包括写入)一个元素时会把它加入到队列尾部

2.3 guava常用接口

/** * 该接口的实现被认为是线程安全的，即可在多线程中调用 * 通过被定义单例使用 */
public interface Cache<K, V> {

/**
* 通过key获取缓存中的value，若不存在直接返回null
*/
V getIfPresent(Object key);

/**
* 通过key获取缓存中的value，若不存在就通过valueLoader来加载该value
* 整个过程为 "if cached, return; otherwise create, cache and return"
* 注意valueLoader要么返回非null值，要么抛出异常，绝对不能返回null
*/
V get(K key, Callable<? extends V> valueLoader) throws ExecutionException;

/**
* 添加缓存，若key存在，就覆盖旧值
*/
void put(K key, V value);

/**
* 删除该key关联的缓存
*/
void invalidate(Object key);  /**
* 删除所有缓存
*/
void invalidateAll();  /**
* 执行一些维护操作，包括清理缓存
*/
void cleanUp();
}

4）缓存回收：
Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。 基于容量的方式内部实现采用LRU算法，基于引用回收很好的利用了Java虚拟机的垃圾回收机制。

1、基于容量的回收（size-based eviction）

如果要规定缓存项的数目不超过固定值，只需使用CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。——在缓存项的数目达到限定值之前，缓存就可能进行回收操作——通常来说，这种情况发生在缓存项的数目逼近限定值时。

2、定时回收（Timed Eviction） 常用第二种方式

CacheBuilder提供两种定时回收的方法：
expireAfterAccess(long, TimeUnit) :缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于容量回收一样。
expireAfterWrite(long, TimeUnit):缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。
定时回收周期性地在写操作中执行，偶尔在读操作中执行。

3、基于引用的回收（Reference-based Eviction）

通过使用弱引用的键、或弱引用的值、或软引用的值，Guava Cache可以把缓存设置为允许垃圾回收
CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（= =），使用弱引用键的缓存用= = 而不是equals比较键。
CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（= =），使用弱引用值的缓存用= =而不是equals比较值。
CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。

DEMO1

4、显式清除

任何时候，你都可以显式地清除缓存项，而不是等到它被回收：
个别清除：Cache.invalidate(key)
批量清除：Cache.invalidateAll(keys)
清除所有缓存项：Cache.invalidateAll()
可以通过磐石或apollo清理guava缓存

5、移除监听器

通过CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener会获取移除通知[RemovalNotification]，其中包含移除原因[RemovalCause]、键和值

DEMO2

6、统计
CacheBuilder.recordStats()：用来开启Guava Cache的统计功能。统计打开后，Cache.stats()方法会返回CacheStats 对象以提供如下统计信息：

hitRate()：缓存命中率；
averageLoadPenalty()：加载新值的平均时间，单位为纳秒；
evictionCount()：缓存项被回收的总数，不包括显式清除。

此外，还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中我们建议密切关注这些数据。
DEMO3

清理什么时候发生？

使用CacheBuilder构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。相反，它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做（如果写操作实在太少的话）。
这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样CacheBuilder就不可用了。
相反，我们把选择权交到你手里。如果你的缓存是高吞吐的，那就无需担心缓存的维护和清理等工作。如果你的缓存只会偶尔有写操作，而你又不想清理工作阻碍了读操作，那么可以创建自己的维护线程，以固定的时间间隔调用Cache.cleanUp()。ScheduledExecutorService可以帮助你很好地实现这样的定时调度。

2.4 guava cache 解析 20201118补充

主要实现的缓存功能有

自动将entry节点加载进缓存结构中；
当缓存的数据超过设置的最大值时，使用LRU算法移除；
具备根据entry节点上次被访问或者写入时间计算它的过期机制；
缓存的key被封装在WeakReference引用内；
缓存的Value被封装在WeakReference或SoftReference引用内；
统计缓存使用过程中命中率、异常率、未命中率等统计数据。

2.4.1 evict清除策略操作

它是在每一次调用操作的开始和结束时触发清理工作，这样比一般的缓存另起线程监控清理相比，可以减少开销，但如果长时间没有调用方法的话，会导致不能及时的清理释放内存空间的问题。evict主要处理四个Queue：1. keyReferenceQueue；2. valueReferenceQueue；3. writeQueue；4. accessQueue。前两个queue是因为WeakReference、SoftReference被垃圾回收时加入的，清理时只需要遍历整个queue，将对应的项从LocalCache中移除即可，这里keyReferenceQueue存放ReferenceEntry，而valueReferenceQueue存放的是ValueReference，要从Cache中移除需要有key，因而ValueReference需要有对ReferenceEntry的引用，这个前面也提到过了。而对后面两个Queue，只需要检查是否配置了相应的expire时间，然后从头开始查找已经expire的Entry，将它们移除即可。

2.4.2 put操作

put操作相对比较简单，首先它需要获得锁，然后尝试做一些清理工作，接下来的逻辑类似ConcurrentHashMap中的rehash，查找位置并注入数据。需要说明的是当找到一个已存在的Entry时，需要先判断当前的ValueRefernece中的值事实上已经被回收了，因为它们可以是WeakReference、SoftReference类型，如果已经被回收了，则将新值写入。并且在每次更新时注册当前操作引起的移除事件，指定相应的原因：COLLECTED、REPLACED等，这些注册的事件在退出的时候统一调用Cache注册的RemovalListener，由于事件处理可能会有很长时间，因而这里将事件处理的逻辑在退出锁以后才做。最后，在更新已存在的Entry结束后都尝试着将那些已经expire的Entry移除。另外put操作中还需要更新writeQueue和accessQueue的语义正确性。

2.4.3 Segment带CacheLoader的get操作

先查找table中是否已存在没有被回收、也没有expire的entry，如果找到，并在CacheBuilder中配置了refreshAfterWrite，并且当前时间间隔已经操作这个事件，则重新加载值，否则，直接返回原有的值；
如果查找到的ValueReference是LoadingValueReference，则等待该LoadingValueReference加载结束，并返回加载的值；
如果没有找到entry，或者找到的entry的值为null，则加锁后，继续在table中查找已存在key对应的entry，如果找到并且对应的entry.isLoading()为true，则表示有另一个线程正在加载，因而等待那个线程加载完成，如果找到一个非null值，返回该值，否则创建一个LoadingValueReference，并调用loadSync加载相应的值，在加载完成后，将新加载的值更新到table中，即大部分情况下替换原来的LoadingValueReference。（划重点）

3 公司哪些业务中使用了guava缓存？

3.1 禅道链接

confluence链接

3.2 相关demo

1、loadingcache方法缓存了异常，那么下一次是缓存异常还是正常数据？
deme4 : 标准中心后台类目缓存

public class BackCategoryCacherImpl implements BackCategoryCacher {private final LoadingCache<Long, BackCategory> backCategoryCache;this.backCategoryCache = CacheBuilder.newBuilder().expireAfterWrite(duration, TimeUnit.HOURS).build(new CacheLoader<Long, BackCategory>() {@Overridepublic BackCategory load(Long categoryId) throws Exception {Response<BackCategory> rBackCategory = backCategoryReadService.findById(categoryId);if (!rBackCategory.isSuccess() || rBackCategory.getResult().getStatus() != 1) {log.warn("failed to find back category(id={}), error code:{}",categoryId, rBackCategory.getError());throw new ServiceException("find back category fail,code: " + rBackCategory.getError());}return rBackCategory.getResult();}});@Overridepublic void afterPropertiesSet() throws Exception {try {try {BackCategory backCategory = backCategoryCache.getUnchecked(21L);System.out.println("第一次查询：" + backCategory);} catch (Exception e) {}BackCategory backCategory1 = backCategoryCache.getUnchecked(21L);System.out.println("第二次查询：" + backCategory1);} catch (Exception e) {e.printStackTrace();}
}

结论：第二次返回正常数据

3.3、guava踩坑

3.3.1、使用guava cache时避免使用weakkeys

使用guava cache时避免使用weakkeys，weakkeys 对key的命中规则是 ==，如果使用非基本类型，会因为key判断不相等导致缓存无法命中。协议配置使用weakkeys，并且未设置缓存大小，导致大量数据进入缓存，占用内存约90%，导致项目频繁fgc，造成内存泄漏，应用响应超时；

3.3.2、使用guava cache时避免笛卡尔积

仅仅需缓存元数据本身，不要缓存其关系，否则造成笛卡尔积。如缓存的数据由A，B，C三张表的维度组成，缓存关系会导致ABC的数据量，如果缓存元数据，则缓存的数据量仅为 A+B+C；

3.3.3、使用guava cache注意事项

1、使用缓存前必须预估缓存的数据大小，并设置缓存的数量或大小；
2、推荐使用softValues，在jvm gc时，可以回收缓存数据；

3.3.4、使用guava cache时异常捕获

注意：捕获异常应该使用Exception，guava 会捕获内部异常后抛出UncheckedExecutionException

  /** @throws UncheckedExecutionException if an exception was thrown while loading the value. (As*     explained in the last paragraph above, this should be an unchecked exception only.)* @throws ExecutionError if an error was thrown while loading the value*/V getUnchecked(K key);skuCache = CacheBuilder.newBuilder().softValues().maximumSize(BaseConstants.MAX_GUAVA_CACHE_SIZE).expireAfterWrite(duration, TimeUnit.MINUTES).build(new CacheLoader<Long, Sku>() {@Overridepublic Sku load(Long skuId) throws Exception {final Response<Sku> rSku = skuReadService.findSkuById(skuId);if(!rSku.isSuccess()){log.warn("failed to find sku(id={}), error code:{}", skuId, rSku.getError());throw new ServiceException(rSku.getError());}return rSku.getResult();}
});// 注意：捕获异常应该使用Exception，而非ServiceException，因为guava 会捕获内部异常后抛出UncheckedExecutionException
try  {skus.add(skuCache.getUnchecked(skuId));
} catch (Exception e) {log.warn("failed to find sku(id={}), error code:{}", skuId, e.getMessage());
}

3.3.5、使用guava cache时避免入参为空

使用 guava cache在读数据时，如果入参为空，会进入cache里面的校验逻辑
解决方法：前置判断，如果key为空，不要调用缓存查询数据

4 优化方向

SpringBoot集成GuavaCache实现本地缓存
demo4

5、如何清理本地缓存 20210128补充

5.1、如果是手动清理

在代码中加上清理缓存的方法

public void updateCateIdAndConfigIdache(String key){log.info("类目配置项cateId+config更新本地缓存 key: {}", key);categoryConfigCache.refresh(key);
}
public void updateConfigIdCache(String key){log.info("实例配置configId更新本地缓存 key: {}", key);instanceConfigCache.refresh(key);
}
public void clearAllCache() {categoryConfigCache.invalidateAll();instanceConfigCache.invalidateAll();
}

使用各类工具清理缓存（apollo，磐石等）
图1：使用apollo进行灰度发布，清理guava缓存
在灰度规则中配置需要执行配置项的ip

apollotrigger 清理缓存的原理：将方法作为配置项保存为value，配置项变更后，java客户端数据实时变更

通过磐石(dubbo调试工具)清理guava缓存

缓存清理工具类接口

public interface CacheClearServiceFacade {/*** 清空本地缓存* 也支持更新操作，需传入的方法名为更新方法方法，参数传入更新的key* @param cacheDto* @return*/Response<String> clearGuavaCache(CacheDto cacheDto);/*** redis 缓存清理* @return*/Response<String> clearRedisCache(CacheDto cacheDto);/*** redis 缓存清理* @return*/Response<String> getRedisCache(CacheDto cacheDto);/*** 根据key 获取本地缓存*/Response<String> getLocalCache(CacheDto cacheDto);
}

缓存清理工具类接口实现类

public class CacheClearServiceFacadeImpl implements CacheClearServiceFacade, ApplicationContextAware {static final String UUID_SALT = "xxxxxxxxxxxxxxxxxx";static final String SUCCESS = "执行成功;";static final String FAIL = "执行失败;";private ApplicationContext applicationContext;@Autowired private JedisClientUtil jedisClientUtil;@Overridepublic Response<String> clearGuavaCache(CacheDto cacheDto) {//"beanName":"cn.gov.zcy.service.category.cache.BackCategoryCacherImpl"String beanName = cacheDto.getBeanName();String methodName = cacheDto.getMethodName();String param = cacheDto.getParam();String paramType = cacheDto.getParamType();String salt = cacheDto.getSalt();Object bean = applicationContext.getBean(beanName);Method method = null;try {if (!UUID_SALT.equals(salt)) {return Response.fail("密码错误");}if(cacheDto.getIpSameFlag()){InetAddress ip4 = Inet4Address.getLocalHost();String ip = StringUtils.trimToEmpty(cacheDto.getIp());if(!ip.equals(ip4.getHostAddress())){return  Response.fail(FAIL+"非本机ip");}}if (StringUtils.isNotEmpty(param) && StringUtils.isNotEmpty(paramType)) {Class<?> classType = Class.forName(paramType);method = bean.getClass().getMethod(methodName, classType);method.invoke(bean, JsonUtil.jsonObject(param, classType));} else {method = bean.getClass().getMethod(methodName);method.invoke(bean);}return Response.ok(SUCCESS);} catch (NoSuchMethodException e) {log.error("beanName:{}, methodName:{} 没有发现方法, cause:{}",beanName,methodName,Throwables.getStackTraceAsString(e));return Response.ok(FAIL);} catch (InvocationTargetException e) {log.error("beanName:{}, methodName:{} invoke异常, cause:{}",beanName,methodName,Throwables.getStackTraceAsString(e));return Response.ok(FAIL);} catch (IllegalAccessException e) {log.error("beanName:{}, methodName:{} 异常, cause:{}",beanName,methodName,Throwables.getStackTraceAsString(e));return Response.ok(FAIL);}catch (Exception e){log.error("beanName:{}, methodName:{} 异常, cause:{}",beanName,methodName,Throwables.getStackTraceAsString(e));return Response.ok(FAIL);}}
}

json为：

[{"salt":"xxxxxxxxxxxxxxx","ip":"172.16.101.112","methodName":"clearAllCache","beanName":"cn.gov.zcy.service.shop.service.ShopInstanceReadServiceImpl"}]

ip地址为：172.16.103.35 172.16.101.112 可以在节点中选择ip，由于上了容器环境，每次部署应用后，ip均会发生变化。
注意：json中的beanName 需要替换，例如清理类目配置项的缓存，就替换为cn.gov.zcy.service.category.service.parana.CategoryAttributeReadServiceImpl

5.2、如果有多台机器，欲自动清理缓存

上面的两种方法都需要手动清理缓存，人力成本较高，现在有一种方案是，在新增/修改数据后，通过MQ+切面来实现所有机器自动清理缓存。

首先定义一个注解，用于处理新增、修改的数据

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheUpdate {/*** 缓存类别  {@link CacheType}* @return*/CacheType type() default CacheType.UN_KNOWN;String paramName() default "";/*** 参数类别 集合为对应的范型  {@link CacheType}* @return*/CacheUpdateParamType paramType() default CacheUpdateParamType.UN_KNOWN;/*** 清空对应key的所有缓存，默认为false，一般只有当数据库发生delete需要*/boolean clearAllCache() default false;
}

然后将注解接入切入点

@Repository
public class ZcyCategoryConfigurationDao extends MyBatisDao<ZcyCategoryConfiguration> {/*** 创建类目配置项   并清理guava缓存* @param insertLists insertLists* @return*/@Override@CacheUpdate(type = CacheType.CATEGORY_CONFIG, paramName = "insertLists", paramType = CacheUpdateParamType.DOMAIN_BEAN)public Integer creates(List<ZcyCategoryConfiguration> insertLists) {return this.sqlSession.insert(this.sqlId("creates"), insertLists);}/*** 批量更新配置项* CacheUpdate 为缓存更新触发的时机* @param updateLists* @return*/@CacheUpdate(type = CacheType.CATEGORY_CONFIG, paramName = "updateLists", paramType = CacheUpdateParamType.DOMAIN_BEAN)public Boolean batchUpdate(List<ZcyCategoryConfiguration> updateLists) {getSqlSession().selectList(this.sqlId("batchUpdateConfig"), updateLists);return true;}
}

定义一个缓存切面，统一处理

@Aspect
@Slf4j
@Component
public class CacheUpdateAspect {@Resourceprivate Map<String, CacheUpdateService> cacheTypeCacheUpdateServiceMap;@Around("@annotation(cacheUpdate)")public Object doCacheUpdate(ProceedingJoinPoint joinPoint, CacheUpdate cacheUpdate) throws Throwable {log.info("方法开始执行完成，aop支持缓存更新处理，处理service：{}", cacheUpdate.type().serviceName);CacheUpdateService processService = cacheTypeCacheUpdateServiceMap.get(cacheUpdate.type().serviceName);if(processService == null){//不支持更新直接返回log.warn("非支持的缓存类型更新，不处理, cacheType : {}", cacheUpdate.type());return joinPoint.proceed();}Map<String, Object> paramValue = getNameAndValue(joinPoint);log.info("执行aop处理，获取参数：{}", JsonUtil.getJsonStr(paramValue));if(MapUtils.isEmpty(paramValue) || !paramValue.containsKey(cacheUpdate.paramName())){//未获取到参数MethodSignature signature = (MethodSignature) joinPoint.getSignature();log.warn("缓存更新方法参数不存在,方法名：{}，需要的参数名：{}", signature.getName(), cacheUpdate.paramName());return joinPoint.proceed();}//前置更新processService.beforeUpdate(paramValue.get(cacheUpdate.paramName()), cacheUpdate.paramType(), cacheUpdate.clearAllCache());//业务逻辑处理Object obj = joinPoint.proceed();//后置更新processService.afterUpdate(paramValue.get(cacheUpdate.paramName()), cacheUpdate.paramType());return obj;}/*** 获取参数Map集合*/Map<String, Object> getNameAndValue(ProceedingJoinPoint joinPoint) {Map<String, Object> param = Maps.newHashMap();Object[] paramValues = joinPoint.getArgs();String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();for (int i = 0; i < paramNames.length; i++) {param.put(paramNames[i], paramValues[i]);}return param;}
}

缓存更新(消息生产和消费)

@Service("categoryConfigUpdateServiceImpl")
@Slf4j
public class CategoryConfigUpdateServiceImpl extends AbstractCacheUpdateService<ZcyCategoryConfiguration> {public static final String SEPARATOR = "_";@Autowiredprivate CacheUpdateProducer cacheUpdateProducer;@Autowiredprivate CategoryAttributeReadServiceImpl categoryAttributeReadServiceImpl;@Overridepublic CacheType support() {return CacheType.CATEGORY_CONFIG;}@Overridepublic void beforeUpdate(Object paramValue, CacheUpdateParamType paramType, boolean clearAllCache) {}@Overridepublic void afterUpdate(Object paramValue, CacheUpdateParamType paramType) {try {List<ZcyCategoryConfiguration> categoryConfig = getParams(paramValue, paramType);if (CollectionUtils.isEmpty(categoryConfig)) {log.warn("后置更新类目配置项缓存未获取到更新参数,不处理");return;}List<String> keys = Lists.newArrayListWithCapacity(categoryConfig.size());for (ZcyCategoryConfiguration config : categoryConfig) {String key = config.getCategoryId() + SEPARATOR + config.getConfigId();keys.add(key);}Map<LocalCacheEnum, List<String>> cacheEnumListMap = Maps.newHashMap();cacheEnumListMap.put(LocalCacheEnum.CATEGORY_CONFIG_CACHE, keys);//发消息 更新id本地缓存cacheUpdateProducer.sendMsg(support(), cacheEnumListMap);} catch (Exception e) {log.error("类目配置项后置缓存更新异常，paramValue：{} ", JsonUtil.getJsonStr(paramValue), e);}}//消费逻辑@Overridepublic void updateLocalCache(Map<LocalCacheEnum, List<String>> paramValues) {paramValues.forEach((key, value) -> {switch (key) {case CATEGORY_CONFIG_CACHE:if (CollectionUtils.isNotEmpty(value)) {value.forEach(cacheKey -> categoryAttributeReadServiceImpl.updateCateIdAndConfigIdache(cacheKey));}break;default:log.warn("类目配置项本地缓存更新，不支持的本地缓存 ：{}", key);}});}@Overridepublic ZcyCategoryConfiguration getParam(Object paramValue, CacheUpdateParamType paramType) {switch (paramType){case DOMAIN_BEAN://todo deletelog.info("类目配置项更新方法参数为zcyCategoryConfiguration");return ((ZcyCategoryConfiguration) paramValue);case IO_DOMAIN_BEAN:default:log.warn("更新类目配置项缓存未获取到指定参数的类型 {}", paramValue.getClass());return null;}}
}

消息生产者逻辑

@Component
@Slf4j
public class CacheUpdateProducer {private final ThreadPoolExecutor SEND_EXECUTOR = new ThreadPoolExecutor(2,4,60, TimeUnit.MINUTES,new ArrayBlockingQueue<>(100));@Autowiredprivate ZMQTemplate zmqTemplate;public void sendMsg(CacheType cacheType,  Map<LocalCacheEnum, List<String>> keys) {SEND_EXECUTOR.submit(() -> sendMsgTask(cacheType, keys));}public void sendMsgTask(CacheType cacheType,  Map<LocalCacheEnum, List<String>> keys) {String message = buildMessage(cacheType, keys);log.info("发送本地缓存变更消息, topic:{}, message:{}", MqConfigContant.ZCY_ITEM_STANDARD_CACHE_UPDATE, message);try {ZMQResponse zmqResponse = zmqTemplate.sendCommonMsg(MqConfigContant.ZCY_ITEM_STANDARD_CACHE_UPDATE, null, null, message);if(!zmqResponse.isSuccess()){log.error("[消息发送失败] 发送本地缓存变更消息, topic:{}, message:{}, cause:{}", MqConfigContant.ITEM_CATEGORY_TOPIC, message, zmqResponse.getResult());}String msgId = zmqResponse.getResult();log.info("发送本地缓存变更消息成功,topic:{}, message:{}, msgId:{}", zmqResponse.getTopic(), message, msgId);} catch (ZMQException e) {log.error("[消息发送异常] 发送本地缓存变更消息异常, message:{}, cause:{}", message, Throwables.getStackTraceAsString(e));}}private String buildMessage(CacheType cacheType, Map<LocalCacheEnum, List<String>> keys) {CacheUpdateMq cacheUpdateMq = new CacheUpdateMq(cacheType, keys);return JsonUtil.getJsonStr(cacheUpdateMq);}
}

消息消费者逻辑

@Slf4j
@Component
public class CacheUpdateConsumer implements MessageCallback {@Autowiredprivate ZMQTemplate zmqTemplate;@Autowiredprivate Map<String, CacheUpdateService> cacheUpdateServiceMap;@PostConstructpublic void init() throws Exception{Map<String, MessageCallback> map = new HashMap<>();map.put(MqConfigContant.ZCY_ITEM_STANDARD_CACHE_UPDATE_CID, this);zmqTemplate.listenMessage(map);}@Overridepublic ZMQConsumeStatus messageArrived(ZMQMessage zmqMessage) {try {CacheUpdateMq cacheUpdateMq = JSON.parseObject(zmqMessage.getBody(), CacheUpdateMq.class);log.info("收到本地缓存更新消息结果 {}", JSON.toJSONString(cacheUpdateMq));if(cacheUpdateMq == null || cacheUpdateMq.getCacheType() == null){log.warn("收到本地缓存更新消息结果不正确，不处理");return ZMQConsumeStatus.CONSUME_SUCCESS;}if (MapUtils.isEmpty(cacheUpdateMq.getKeys())) {log.warn("更新本地缓存参数为空");return ZMQConsumeStatus.CONSUME_SUCCESS;}if(!cacheUpdateServiceMap.containsKey(cacheUpdateMq.getCacheType().serviceName)){log.warn("收到本地缓存更新消息结果中不包含可处理的缓存，不处理");return ZMQConsumeStatus.CONSUME_SUCCESS;}cacheUpdateServiceMap.get(cacheUpdateMq.getCacheType().serviceName).updateLocalCache(cacheUpdateMq.getKeys());return ZMQConsumeStatus.CONSUME_SUCCESS;}catch (Exception e){log.error("本地缓存更新消息处理异常", e);return ZMQConsumeStatus.RECONSUME_LATER;}}
}

达到的效果，如果dao层有写方法被调用，会触发aop的后置更新逻辑，实时清理本地guava缓存

6、caffeine缓存 20210128补充

1、简介：

Caffeine是基于java8实现的新一代缓存工具，缓存性能接近理论最优。可以看作是Guava Cache的增强版，API上两者类似，主要区别体现在内存淘汰机制;
因为在现有算法的局限性下，会导致缓存数据的命中率或多或少的受损，而命中率又是缓存的重要指标。Caffeine 使用Window TinyLfu回收策略，==提供了一个近乎最佳的命中率 ==。

2、实现机制

TinyLFU维护了近期访问记录的频率信息，作为一个过滤器，当新记录来时，只有满足TinyLFU要求的记录才可以被插入缓存。它需要解决两个挑战：一个是如何避免维护频率信息的高开销；另一个是如何反应随时间变化的访问模式。
在Count-Min Sketch中，如果你的缓存大小是100，他会生成一个long数组大小是和100最接近的2的幂的数，也就是128。而这个数组将会记录我们的访问频率。在caffeine中规定频率最大为15，15的二进制位1111，总共是4位，而Long型是64位。而Caffeine用了四种hash算法，每个Long型被分为四段，每段里面保存的是四个算法的频率。这样做的好处是可以进一步减少Hash冲突，原先128大小的hash，就变成了128X4。

如下图所示：

3、读写性能

在guava cache中我们说过其读写操作中夹杂着过期时间的处理，也就是你在一次Put操作中有可能还会做淘汰操作，所以其读写性能会受到一定影响，而在caffeine，对这些事件的操作是通过异步操作，他将事件提交至队列，这里的队列的数据结构是RingBuffer，然后会通过默认的ForkJoinPool.commonPool()，或者自己配置线程池，进行取队列操作，然后在进行后续的淘汰，过期操作。读写也是有不同的队列，在caffeine中认为快取读比写多很多，所以对于写操作是所有执行绪共享一个Ringbuffer。

4、数据淘汰策略

在caffeine所有的数据都在ConcurrentHashMap中，这个和guava cache不同，guava cache是自己实现了个类似ConcurrentHashMap的结构。在caffeine中有三个记录引用的LRU队列:
Eden队列：在caffeine中规定只能为缓存容量的%1,如果size=100,那这个队列的有效大小就等于1。这个队列中记录的是新到的数据，防止突发流量由于之前没有访问频率，而导致被淘汰。新建最开始其实是没有访问频率的，防止上线之后被其他缓存淘汰出去，而加入这个区域。伊甸区，最舒服最安逸的区域，在这里很难被其他数据淘汰。
Probation队列：叫做缓刑队列，在这个队列就代表你的数据相对比较冷，马上就要被淘汰了。这个有效大小为size减去eden减去protected。
Protected队列:在这个队列中，可以稍微放心一下了，你暂时不会被淘汰，但是别急，如果Probation队列没有数据了或者Protected数据满了，你也将会被面临淘汰的尴尬局面。当然想要变成这个队列，需要把Probation访问一次之后，就会提升为Protected队列。这个有效大小为(size减去eden) X 80% 如果size =100，就会是79。

1、所有的新数据都会进入Eden。
2、Eden满了，淘汰进入Probation。
3、如果在Probation中访问了其中某个数据，则这个数据升级为Protected。
4、如果Protected满了又会继续降级为Probation。
5、对于发生数据淘汰的时候，会从Probation中进行淘汰。会把这个队列中的数据队头称为受害者，这个队头肯定是最早进入的，按照LRU队列的算法的话那他其实他就应该被淘汰，但是在这里只能叫他受害者，这个队列是缓刑队列，代表马上要给他行刑了。这里会取出队尾叫候选者，也叫攻击者。这里受害者会和攻击者PK决出我们应该被淘汰的。

通过我们的Count-Min Sketch中的记录的频率数据有以下几个判断:

1、如果攻击者大于受害者，那么受害者就直接被淘汰。
2、如果攻击者<=5，那么直接淘汰攻击者，作者认为设置一个预热的门槛会让整体命中率更高。
3、其他情况，随机淘汰。

5、其他优化
过期策略：在Caffeine中有个scheduleDrainBuffers方法，用来进行我们的过期任务的调度，在我们读写之后都会对其进行调用:
更新策略：建立一个CacheLodaer来进行重新整理,这里是同步进行的，可以通过buildAsync方法进行非同步构建，自动刷新只存在读操作之后；

总结：
Guava Cache基于ConcurrentHashMap的优秀设计借鉴，在高并发场景支持和线程安全上都有相应的改进策略，使用Reference引用命令，提升高并发下的数据访问速度并保持了GC的可回收，有效节省空间；同时，write链和access链的设计，能更灵活、高效的实现多种类型的缓存清理策略，包括基于容量的清理、基于时间的清理、基于引用的清理等；编程式的build生成器管理，让使用者有更多的自由度，能够根据不同场景设置合适的模式。

GuavaCache的实现代码中没有启动任何线程，Cache中的所有维护操作，包括清除缓存、写入缓存等，都需要外部调用来实现。这在需要低延迟服务场景中使用时，需要关注，可能会在某个调用的响应时间突然变大。GuavaCache毕竟是一款面向本地缓存的，轻量级的Cache，适合缓存少量数据。如果你想缓存上千万数据，可以为每个key设置不同的存活时间，并且高性能，那并不适合使用GuavaCache。

Google guava第一讲：guava缓存实战/使用场景/缓存清理/最佳实践/caffeine实战相关推荐

玩转ECS第7讲 | ECS数据保护-数据备份新特性与最佳实践
简介:本文中,阿里云智能弹性计算专家余初武(悟元)将结合阿里云近期推出的数据备份新特性(快照极速备份.一致性快照组)来介绍云上环境如何做数据备份的最佳实践:适合需要构建云上架构的工程师,架构师和云上实 ...
.NET Core开发实战（定义API的最佳实践）Source Generators版
前言极客时间上的<.NET Core开发实战>是一门非常好的课程,作者肖伟宇在第31课(https://time.geekbang.org/course/detail/100044601 ...
老师讲的真棒！Android-性能优化最佳实践
本文由玉刚说写作平台提供写作赞助原作者:Mr.S 版权声明:本文版权归微信公众号玉刚说所有,未经许可,不得以任何形式转载原文链接:https://juejin.im/post/5b50b017f2 ...
【企业架构设计实战】大数据架构最佳实践
目录数据架构概述什么是数据? 什么是数据架构
Redis第一讲：相关的基础知识/数据类型/缓存的过期策略/双写一致性/内存存储和持久化
Redis第一讲:相关的基础知识摘要:本文是Redis(6.2.1)详解的第一讲,介绍Redis相关的基础知识,内存存储和持久化,Redis作缓存使用时的注意要点,常见的数据类型,缓存的过期策略,R ...
javascript实战第一讲：聊天窗口
javascript实战第一讲:聊天窗口第一种方式:实现聊天功能的javascipt: <script> window.οnlοad=function(){ //页面加载完毕后,执行下面 ...
google Guava包RateLimiter使用最佳实践
以下是使用Guava RateLimiter的最佳实践: 1 创建RateLimiter对象的最佳实践在创建RateLimiter对象时,建议使用静态工厂方法来创建,因为它提供了更清晰的API,并且 ...
Guava Cache 原理分析与最佳实践
前言在大部分互联网架构中 Cache 已经成为了必可不少的一环.常用的方案有大家熟知的 NoSQL 数据库(Redis.Memcached),也有大量的进程内缓存比如 EhCache .Guava ...
【Guava】使用Guava的RateLimiter做限流
2019独角兽企业重金招聘Python工程师标准>>> 一.常见的限流算法目前常用的限流算法有两个:漏桶算法和令牌桶算法. 1.漏桶算法漏桶算法的原理比较简单,请求进入到漏桶中, ...

Google guava第一讲：guava缓存实战/使用场景/缓存清理/最佳实践/caffeine实战