guava缓存实战及使用场景

Guava缓存实战及使用场景

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

1 为什么使用本地缓存

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

1.1 适用场景

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

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

2.1 LoadingCache demo1

• 导入 Maven 引用

  
    com.google.guava  
    guava
    19.0  
 

• 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>() {
              @Override
              public 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[] segments	Segment继承于ReetrantLock，减小锁粒度，提高并发效率
2	AtomicReferenceArray> table	类似于HasmMap中的table一样，相当于entry的容器
3	ReferenceEntry referenceEntry	基于引用的Entry,其实现类有弱引用Entry,强引用Entry等
4	ReferenceQueue keyReferenceQueue	已经被GC，需要内部清理的键引用队列
5	ReferenceQueue valueReferenceQueue	已经被GC，需要内部清理的值引用队列
6	Queue> recencyQueue	记录升级可访问列表清单时的entries,当segment上达到临界值或发生写操作时该队列会被清空
7	Queue> writeQueue	按照写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部
8	Queue> 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可以帮助你很好地实现这样的定时调度。

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>() {
                @Override
                 public 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();
                 }
             });
  @Override
 public 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();
       }
}

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

2、guava踩坑

• 1、使用guava cache时避免使用weakkeys，weakkeys 对key的命中规则是 ==，如果使用非基本类型，会因为key判断不相等导致缓存无法命中。 协议配置使用weakkeys，并且未设置缓存大熊啊，导致大量数据进入缓存，占用内存约90%，导致项目频繁fgc，应用响应超时；
• 2、仅仅需缓存元数据本身，不要缓存其关系，否则造成笛卡尔积。如缓存的数据由A，B，C三张表的维度组成，缓存关系会导致ABC的数据量，如果缓存元数据，则缓存的数据量仅为 A+B+C；
• 3、使用缓存前必须预估缓存的数据大小，并设置缓存的数量或大小

4 优化方向

• SpringBoot集成GuavaCache实现本地缓存
• demo4

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