guava cache(LoadingCache)使用和源码分析

guava cache使用和源码分析

• guava cache的优点和使用场景，用来判断业务中是否适合使用此缓存
• 介绍常用的方法，并给出示例，作为使用的参考
• 深入解读源码。

guava简介

guava cache是一个本地缓存。有以下优点：

• 很好的封装了get、put操作，能够集成数据源。
  一般我们在业务中操作缓存，都会操作缓存和数据源两部分。如：put数据时，先插入DB，再删除原来的缓存；ge数据时，先查缓存，命中则返回，没有命中时，需要查询DB，再把查询结果放入缓存中。 guava cache封装了这么多步骤，只需要调用一次get/put方法即可。
• 线程安全的缓存，与ConcurrentMap相似，但前者增加了更多的元素失效策略，后者只能显示的移除元素。
• Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。定时回收有两种：按照写入时间，最早写入的最先回收；按照访问时间，最早访问的最早回收。
• 监控缓存加载/命中情况。

常用方法

• V getIfPresent(Object key) 获取缓存中key对应的value，如果缓存没命中，返回null。return value if cached, otherwise return null.
• V get(K key) throws ExecutionException 获取key对应的value，若缓存中没有，则调用LocalCache的load方法，从数据源中加载，并缓存。 return value if cached, otherwise load, cache and return.
• void put(K key, V value) if cached, return; otherwise create, cache , and return.
• void invalidate(Object key); 删除缓存
• void invalidateAll(); 清楚所有的缓存，相当远map的clear操作。
• long size(); 获取缓存中元素的大概个数。为什么是大概呢？元素失效之时，并不会实时的更新size，所以这里的size可能会包含失效元素。
• CacheStats stats(); 缓存的状态数据，包括(未)命中个数，加载成功/失败个数，总共加载时间，删除个数等。
• ConcurrentMap<K, V> asMap(); 将缓存存储到一个线程安全的map中。

批量操作就是循环调用上面对应的方法，如：

• ImmutableMap<K, V> getAllPresent(Iterable<?> keys);
• void putAll(Map<? extends K,? extends V> m);
• void invalidateAll(Iterable<?> keys);

• import com.google.common.cache.CacheBuilder;
  import com.google.common.cache.CacheLoader;
  import com.google.common.cache.LoadingCache;
  import java.util.concurrent.TimeUnit;
  
  public class guavaSample {
  
      public static void main(String[] args) {
  
          LoadingCache<String, Integer> cache = CacheBuilder.newBuilder()
                  .maximumSize(10)  //最多存放十个数据
                  .expireAfterWrite(10, TimeUnit.SECONDS)  //缓存200秒
                  .recordStats()   //开启 记录状态数据功能
                  .build(new CacheLoader<String, Integer>() {
                      //数据加载，默认返回-1,也可以是查询操作，如从DB查询
                      @Override
                      public Integer load(String key) throws Exception {
                          return -1;
                      }
                  });
  
          //只查询缓存，没有命中，即返回null。 miss++
          System.out.println(cache.getIfPresent("key1")); //null
          //put数据，放在缓存中
          cache.put("key1", 1);
          //再次查询，已存在缓存中, hit++
          System.out.println(cache.getIfPresent("key1")); //1
          //失效缓存
          cache.invalidate("key1");
          //失效之后，查询，已不在缓存中, miss++
          System.out.println(cache.getIfPresent("key1")); //null
          
          try{
              //查询缓存，未命中，调用load方法，返回-1. miss++
              System.out.println(cache.get("key2"));   //-1
              //put数据，更新缓存
              cache.put("key2", 2);
              //查询得到最新的数据, hit++
              System.out.println(cache.get("key2"));    //2
              System.out.println("size :" + cache.size());  //1
  
              //插入十个数据
              for(int i=3; i<13; i++){
                  cache.put("key"+i, i);
              }
              //超过最大容量的，删除最早插入的数据，size正确
              System.out.println("size :" + cache.size());  //10
              //miss++
              System.out.println(cache.getIfPresent("key2"));  //null
  
              Thread.sleep(5000); //等待5秒
              cache.put("key1", 1);
              cache.put("key2", 2);
              //key5还没有失效，返回5。缓存中数据为key1，key2，key5-key12. hit++
              System.out.println(cache.getIfPresent("key5")); //5
  
              Thread.sleep(5000); //等待5秒
              //此时key5-key12已经失效，但是size没有更新
              System.out.println("size :" + cache.size());  //10
              //key1存在, hit++
              System.out.println(cache.getIfPresent("key1")); //1
              System.out.println("size :" + cache.size());  //10
              //获取key5，发现已经失效，然后刷新缓存，遍历数据，去掉失效的所有数据, miss++
              System.out.println(cache.getIfPresent("key5")); //null
              //此时只有key1，key2没有失效
              System.out.println("size :" + cache.size()); //2
  
              System.out.println("status, hitCount:" + cache.stats().hitCount()
                  + ", missCount:" + cache.stats().missCount()); //4,5
          }catch (Exception e){
              System.out.println(e.getMessage());
          }
      }
  }

  guava cache源码解析

  先了解一些主要类和接口：

  • CacheBuilder：类，缓存构建器。构建缓存的入口，指定缓存配置参数并初始化本地缓存。
    CacheBuilder在build方法中，会把前面设置的参数，全部传递给LocalCache，它自己实际不参与任何计算。这种初始化参数的方法值得借鉴，代码简洁易读。
  • CacheLoader：抽象类。用于从数据源加载数据，定义load、reload、loadAll等操作。
  • Cache：接口，定义get、put、invalidate等操作，这里只有缓存增删改的操作，没有数据加载的操作。
  • AbstractCache：抽象类，实现Cache接口。其中批量操作都是循环执行单次行为，而单次行为都没有具体定义。
  • LoadingCache：接口，继承自Cache。定义get、getUnchecked、getAll等操作，这些操作都会从数据源load数据。
  • AbstractLoadingCache：抽象类，继承自AbstractCache，实现LoadingCache接口。
  • LocalCache：类。整个guava cache的核心类，包含了guava cache的数据结构以及基本的缓存的操作方法。
  • LocalManualCache：LocalCache内部静态类，实现Cache接口。其内部的增删改缓存操作全部调用成员变量localCache（LocalCache类型）的相应方法。
  • LocalLoadingCache：LocalCache内部静态类，继承自LocalManualCache类，实现LoadingCache接口。其所有操作也是调用成员变量localCache（LocalCache类型）的相应方法。

  综上，guava cache的核心操作，都在LocalCache中实现。
  其他：CacheStats：缓存加载/命中统计信息。

  在看具体的代码之前，先来简单了解一下LocalCache的数据结构。
  LocalCache的数据结构如下所示：

  LocalCache的数据结构与ConcurrentHashMap很相似，都由多个segment组成，且各segment相对独立，互不影响，所以能支持并行操作。每个segment由一个table和若干队列组成。缓存数据存储在table中，其类型为AtomicReferenceArray<ReferenceEntry<K, V>>，即一个数组，数组中每个元素是一个链表。两个队列分别是writeQueue和accessQueue，用来存储写入的数据和最近访问的数据，当数据过期，需要刷新整体缓存（见上述示例最后一次cache.getIfPresent("key5")）时，遍历队列，如果数据过期，则从table中删除。segment中还有基于引用场景的其他队列，这里先不做讨论。

  CacheBuilder

  CacheBuilder是缓存配置和构建入口，先看一些属性。CacheBuilder的设置操作都是为这些属性赋值。

      //缓存的默认初始化大小

   //缓存的默认初始化大小
      private static final int DEFAULT_INITIAL_CAPACITY = 16;
      // LocalCache默认并发数，用来评估Segment的个数
      private static final int DEFAULT_CONCURRENCY_LEVEL = 4;
      //默认的缓存过期时间
      private static final int DEFAULT_EXPIRATION_NANOS = 0;
      
      static final int UNSET_INT = -1;
      int initialCapacity = UNSET_INT;//初始缓存大小
      int concurrencyLevel = UNSET_INT;//用于计算有几个并发
      long maximumSize = UNSET_INT;//cache中最多能存放的缓存entry个数
      long maximumWeight = UNSET_INT;
      
      Strength keyStrength;//键的引用类型（strong、weak、soft）
      Strength valueStrength;//值的引用类型（strong、weak、soft）
  
      long expireAfterWriteNanos = UNSET_INT;//缓存超时时间（起点：缓存被创建或被修改）
      long expireAfterAccessNanos = UNSET_INT;//缓存超时时间（起点：缓存被创建或被修改或被访问）
      //元素被移除的监听器
       RemovalListener<? super K, ? super V> removalListener;
       //状态计数器，默认为NULL_STATS_COUNTER，即不启动计数功能
       Supplier<? extends StatsCounter> statsCounterSupplie

  CacheBuilder构建缓存有两个方法：

  //构建一个具有数据加载功能的缓存
    public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(
        CacheLoader<? super K1, V1> loader) {
      checkWeightWithWeigher();
      //调用LocalCache构造方法
      return new LocalCache.LocalLoadingCache<K1, V1>(this, loader);
    }
    
    //构建一个没有数据加载功能的缓存
     public <K1 extends K, V1 extends V> Cache<K1, V1> build() {
      checkWeightWithWeigher();
      checkNonLoadingCache();
      //调用LocalCache构造方法，但loader为null
      return new LocalCache.LocalManualCache<K1, V1>(this);
    }
  
   //被CacheBuilder的build方法调用，将其参数传递给LocalCache
    LocalCache(
        CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {
      //默认并发水平是4，即四个Segment（但要注意concurrencyLevel不一定等于Segment个数）
      //Segment个数：一个刚刚大于或等于concurrencyLevel且是2的几次方的一个数,在后面会有segmentCount赋值过程    
      concurrencyLevel = Math.min(builder.getConcurrencyLevel(), MAX_SEGMENTS);
  
      keyStrength = builder.getKeyStrength();//默认为Strong，即强引用
      valueStrength = builder.getValueStrength();//默认为Strong，即强引用
  
      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());
      entryFactory = EntryFactory.getFactory(keyStrength, usesAccessEntries(), usesWriteEntries());
      globalStatsCounter = builder.getStatsCounterSupplier().get();
      defaultLoader = loader;
  
      int initialCapacity = Math.min(builder.getInitialCapacity(), MAXIMUM_CAPACITY);
      if (evictsBySize() && !customWeigher()) {
        initialCapacity = Math.min(initialCapacity, (int) maxWeight);
      }
  
     //调整segmentCount个数，通过位移实现，所以是2的n次方。
      int segmentShift = 0;
      int segmentCount = 1;
      while (segmentCount < concurrencyLevel
             && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
        ++segmentShift;
        segmentCount <<= 1;
      }
      this.segmentShift = 32 - segmentShift;
      segmentMask = segmentCount - 1;
      //初始化segments
      this.segments = newSegmentArray(segmentCount);
      //每个segment的大小
      int segmentCapacity = initialCapacity / segmentCount;
      if (segmentCapacity * segmentCount < initialCapacity) {
        ++segmentCapacity;
      }
  
      int segmentSize = 1;
      while (segmentSize < segmentCapacity) {
        segmentSize <<= 1;
      }
      //初始化Segments
      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初始化操作，结构与上面图中大致相同（图中省去部分队列）
      Segment(LocalCache<K, V> map, int initialCapacity, long maxSegmentWeight,
          StatsCounter statsCounter) {
        this.map = map;
        this.maxSegmentWeight = maxSegmentWeight;
        this.statsCounter = checkNotNull(statsCounter);
        //初始化table
        initTable(newEntryArray(initialCapacity));
       //key引用队列
        keyReferenceQueue = map.usesKeyReferences()
             ? new ReferenceQueue<K>() : null;
       //value引用队列
        valueReferenceQueue = map.usesValueReferences()
             ? new ReferenceQueue<V>() : null;
  
        recencyQueue = map.usesAccessQueue()
            ? new ConcurrentLinkedQueue<ReferenceEntry<K, V>>()
            : LocalCache.<ReferenceEntry<K, V>>discardingQueue();
        //写入元素队列
        writeQueue = map.usesWriteQueue()
            ? new WriteQueue<K, V>()
            : LocalCache.<ReferenceEntry<K, V>>discardingQueue();
       //访问元素队列
        accessQueue = map.usesAccessQueue()
            ? new AccessQueue<K, V>()
            : LocalCache.<ReferenceEntry<K, V>>discardingQueue();
      }

  LocalCache

  LocalCache是guava cache的核心类。LocalCache的构造函数在上面已经分析过，接着看下核心方法。

  对于get(key, loader)方法流程：

  • 对key做hash，找到存储的segment及数组table上的位置；
  • 链表上查找entry，如果entry不为空，且value没有过期，则返回value，并刷新entry。
  • 若链表上找不到entry，或者value已经过期，则调用lockedGetOrLoad。
  • 锁住整个segment，遍历entry可能在的链表，查看数据是否存在是否过期，若存在则返回。若过期则删除（table，各种queue）。若不存在，则新建一个entry插入table。放开整个segment的锁。
  • 锁住entry，调用loader的reload方法，从数据源加载数据，然后调用storeLoadedValue更新缓存。
  • storeLoadedValue时，锁住整个segment，将value设置到entry中，并设置相关数据（入写入/访问队列，加载/命中数据等）。

  getAll(keys)方法：

  • 循环调用get方法，从缓存中获取key对应的value。没有命中的记录下来。
  • 如果有没有命中的key，调用loadAll(keys，loader)方法加载数据。
  • 将加载的数据依次缓存，调用segment的put(K key, int hash, V value, boolean onlyIfAbsent)方法。
  • put时，锁住整个segment，将数据插入链表，更新统计数据。

  put(key,value)方法：

  • 对key做hash，找到segment的位置和table上的位置；
  • 锁住整个segment，将数据插入链表，更新统计数据。

  putAll(map) 循环调用put方法。

  putIfAbsent(key, value) 缓存中，键值对不存在的时候才插入。

  实践

  guava cache是将数据源中的数据缓存在本地，那如果我们想把远端数据源中的数据缓存在远端 分布式缓存（如redis），可以怎么来使用guava cache的方式进行封装呢？
  可以仿照guava写一个简单的缓存，定义如下：
  CacheBuilder类 ： 配置缓存参数，构建缓存。同上面所讲。
  Cache接口：定义增删查接口。
  MyCache类：实现Cache接口，put -> 存入DB，更新缓存； get -> 查询缓存，存在即返回；若不存在，查询DB，更新缓存，返回。
  CacheLoader类：供MyCache调用，get和getAll时提供单次查DB和批量查DB。