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。

参考

Google guava cache源码解析1--构建缓存器

Google Guava 缓存

后续

guava cache基于引用回收相关；

删除监听器相关。