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

1、guava cache

• 当下最常用最简单的本地缓存
• 线程安全的本地缓存
• 类似于ConcurrentHashMap（或者说成就是一个ConcurrentHashMap，只是在其上多添加了一些功能）

2、使用实例

具体在实际中使用的例子，去查看《第七章 企业项目开发--本地缓存guava cache》，下面只列出测试实例：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class Hello{

    LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .expireAfterWrite(20, TimeUnit.MINUTES)// 缓存20分钟
            .maximumSize(1000)// 最多缓存1000个对象
            .build(new CacheLoader<String, String>() {
                public String load(String key) throws Exception {
                    if(key.equals("hi")){
                        return null;
                    }
                    return key+"-world";
                }
            });

    public static void main(String[] args){
        Hello hello = new Hello();
        System.out.println(hello.testCache.getIfPresent("hello"));//null
        hello.testCache.put("123", "nana");//存放缓存
        System.out.println(hello.testCache.getIfPresent("123"));//nana
        try {
            System.out.println(hello.testCache.get("hello"));//hello-world
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(hello.testCache.getIfPresent("hello"));//hello-world
        /***********测试null*************/
        System.out.println(hello.testCache.getIfPresent("hi"));//null
        try {
            System.out.println(hello.testCache.get("hi"));//抛异常
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

在这个方法中，基本已经覆盖了guava cache常用的部分。

• 构造缓存器
  • 缓存器的构建没有使用构造器而不是使用了构建器模式，这是在存在多个可选参数的时候，最合适的一种配置参数的方式，具体参看《effective Java（第二版）》第二条建议。
• 常用的三个方法
  • get(Object key)
  • getIfPresent(Object key)
  • put(Object key, Object value)

3、源代码

在阅读源代码之前，强烈建议，先看一下"Java并发包类源码解析"中的《第二章 ConcurrentHashMap源码解析》，链接如下：

http://www.cnblogs.com/java-zhao/p/5113317.html

对于源码部分，由于整个代码的核心类LocalCache有5000多行，所以只介绍上边给出的实例部分的相关源码解析。本节只说一下缓存器的构建，即如下代码部分：

    LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .expireAfterWrite(20, TimeUnit.MINUTES)// 缓存20分钟(时间起点：entry的创建或替换（即修改）)
            //.expireAfterAccess(10, TimeUnit.MINUTES)//缓存10分钟(时间起点：entry的创建或替换（即修改）或最后一次访问)
            .maximumSize(1000)// 最多缓存1000个对象
            .build(new CacheLoader<String, String>() {
                public String load(String key) throws Exception {
                    if(key.equals("hi")){
                        return null;
                    }
                    return key+"-world";
                }
            });

说明：该代码的load()方法会在之后将get(Object key)的时候再说，这里先不说了。

对于这一块儿，由于guava cache这一块儿的代码虽然不难，但是容易看的跑偏，一会儿就不知道跑到哪里去了，所以我下边先给出guava cache的数据结构以及上述代码的执行流程，然后大家带着这个数据结构和执行流程去分析下边的源代码，分析完源代码之后，我在最后还会再将cache的数据结构和构建缓存器的执行流程给出，并会结合我们给出的开头实例代码来套一下整个流程，最后画出初始化构建出来的缓存器（其实，这个缓存器就是上边以及文末给出的cache的数据结构图）。

guava cache的数据结构图：

需要说明的是：

• 每一个Segment中的有效队列（废弃队列不算）的个数最多可能不止一个
• 上图与ConcurrentHashMap及其类似，其中的ReferenceEntry[i]用于存放key-value
• 每一个ReferenceEntry[i]都会存放一个链表，当然采用的也是Entry替换的方式。
• 队列用于实现LRU缓存回收算法
• 多个Segment之间互不打扰，可以并发执行
• 各个Segment的扩容只需要扩自己的就好，与其他Segment无关
• 根据需要设置好初始化容量与并发水平参数，可以有效避免扩容带来的昂贵代价，但是设置的太大了，又会耗费很多内存，要衡量好

后边三条与ConcurrentHashMap一样

guava cache的数据结构的构建流程：

1）构建CacheBuilder实例cacheBuilder

2）cacheBuilder实例指定缓存器LocalCache的初始化参数

3）cacheBuilder实例使用build()方法创建LocalCache实例（简单说成这样，实际上复杂一些）

3.1）首先为各个类变量赋值（通过第二步中cacheBuilder指定的初始化参数以及原本就定义好的一堆常量）

3.2）之后创建Segment数组

3.3）最后初始化每一个Segment[i]

3.3.1）为Segment属性赋值

3.3.2）初始化Segment中的table，即一个ReferenceEntry数组（每一个key-value就是一个ReferenceEntry）

3.3.3）根据之前类变量的赋值情况，创建相应队列，用于LRU缓存回收算法

类结构：（这个不看也罢）

• CacheBuilder：设置LocalCache的相关参数，并创建LocalCache实例
• CacheLoader：有用的部分就是一个load()，用于实现"取缓存-->若不存在，先计算，在缓存-->取缓存"的原子操作
• LocalCache：整个guava cache的核心类，包含了guava cache的数据结构以及基本的缓存的操作方法
• LocalLoadingCache：LocalCache的一个静态内部类，这里的get(K key)是外部调用get(K key)入口
• LoadingCache接口：继承于Cache接口，定义了get(K key)
• Cache接口：定义了getIfPresent(Object key)和put(K key, V value)
• LocalManualCache：LocalCache的一个静态内部类，是LocalLoadingCache的父类，这里的getIfPresent(Object key)和put(K key, V value)也是外部方法的入口

关于上边的这些说明，结合之后的源码进行看就好了。

注：如果在源码中有一些注释与最后的套例子的注释不同的话，以后者为准

3.1、构建CacheBuilder+为LocalCache设置相关参数+创建LocalCache实例

CacheBuilder的一些属性：

    private static final int DEFAULT_INITIAL_CAPACITY = 16;//用于计算每个Segment中的hashtable的大小
    private static final int DEFAULT_CONCURRENCY_LEVEL = 4;//用于计算有几个Segment
    private static final int DEFAULT_EXPIRATION_NANOS = 0;//默认的缓存过期时间

    static final int UNSET_INT = -1;

    int initialCapacity = UNSET_INT;//用于计算每个Segment中的hashtable的大小
    int concurrencyLevel = UNSET_INT;//用于计算有几个Segment
    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;//缓存超时时间（起点：缓存被创建或被修改或被访问）

CacheBuilder-->newCacheBuilder()：创建一个CacheBuilder实例

    /**
     * 采用默认的设置（如下）创造一个新的CacheBuilder实例
     * 1、strong keys
     * 2、strong values
     * 3、no automatic eviction of any kind.
     */
    public static CacheBuilder<Object, Object> newBuilder() {
        return new CacheBuilder<Object, Object>();//new 一个实例
    }

接下来，使用构建器模式指定一些属性值（这里的话，就是超时时间：expireAfterWriteNanos+cache中最多能放置的entry个数：maximumSize），这里的entry指的就是一个缓存（key-value对）

CacheBuilder-->expireAfterWrite(long duration, TimeUnit unit)

    /**
     * 指明每一个entry（key-value）在缓存中的过期时间
     * 1、时间的参考起点：entry的创建或值的修改
     * 2、过期的entry也许会被计入缓存个数size（也就是说缓存个数不仅仅只有存活的entry）
     * 3、但是过期的entry永远不会被读写
     */
    public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
        /*
         * 检查之前是否已经设置过缓存超时时间
         */
        checkState(expireAfterWriteNanos == UNSET_INT,//正确条件：之前没有设置过缓存超时时间
                   "expireAfterWrite was already set to %s ns",//不符合正确条件的错误信息
                   expireAfterWriteNanos);
        /*
         * 检查设置的超时时间是否大于等于0，当然，通常情况下，我们不会设置缓存为0
         */
        checkArgument(duration >= 0, //正确条件
                      "duration cannot be negative: %s %s",//不符合正确条件的错误信息，下边的是错误信息中的错误参数
                      duration,
                      unit);
        this.expireAfterWriteNanos = unit.toNanos(duration);//根据输入的时间值与时间单位，将时间值转换为纳秒
        return this;
    }

注意：

• 设置超时时间，注意时间的起点是entry的创建或替换（修改）
• expireAfterAccess(long duration, TimeUnit unit)方法的时间起点：entry的创建或替换（修改）或被访问

CacheBuilder-->maximumSize(long size)

    /**
     * 指定cache中最多能存放的entry（key-value）个数maximumSize
     * 注意：
     * 1、在entry个数还未达到这个指定个数maximumSize的时候，可能就会发生缓存回收
     * 上边这种情况发生在cache size接近指定个数maximumSize，
     * cache就会回收那些很少会再被用到的缓存（这些缓存会使最近没有被用到或很少用到的），其实说白了就是LRU算法回收缓存
     * 2、maximumSize与maximumWeight不能一起使用，其实后者也很少会使用
     */
    public CacheBuilder<K, V> maximumSize(long size) {
        /* 检查maximumSize是否已经被设置过了 */
        checkState(this.maximumSize == UNSET_INT,
                   "maximum size was already set to %s",
                   this.maximumSize);
        /* 检查maximumWeight是否已经被设置过了（这就是上边说的第二条）*/
        checkState(this.maximumWeight == UNSET_INT,
                   "maximum weight was already set to %s",
                   this.maximumWeight);
        /* 这是与maximumWeight配合的一个属性 */
        checkState(this.weigher == null,
                   "maximum size can not be combined with weigher");
        /* 检查设置的maximumSize是不是>=0，通常不会设置为0，否则不会起到缓存作用 */
        checkArgument(size >= 0, "maximum size must not be negative");
        this.maximumSize = size;
        return this;
    }

注意：

• 设置整个cache（而非每个Segment）中最多可存放的entry的个数

CacheBuilder-->build(CacheLoader<? super K1, V1> loader)

    /**
     * 建立一个cache，该缓存器通过使用传入的CacheLoader，
     * 既可以获取已给定key的value，也能够自动的计算和获取缓存（这说的就是get(Object key)的三步原子操作）
     * 当然，这里是线程安全的，线程安全的运行方式与ConcurrentHashMap一致
     */
    public <K1 extends K, V1 extends V> LoadingCache<K1, V1> build(CacheLoader<? super K1, V1> loader) {
        checkWeightWithWeigher();
        return new LocalCache.LocalLoadingCache<K1, V1>(this, loader);
    }

注意：

• 要看懂该方法，需要了解一些泛型方法的使用方式与泛型限界
• 该方法的返回值是一个LoadingCache接口的实现类LocalLoadingCache实例
• 在build方法需要传入一个CacheLoader的实例，实际使用中使用了匿名内部类来实现的，源码的话，就是一个无参构造器，什么也没做，传入CacheLoader实例的意义就是"类结构"部分所说的load()方法

在上边调用build时，整个代码的执行权其实就交给了LocalCache.

3.2、LocalCache

LocalLoadingCahe构造器

    static class LocalLoadingCache<K, V> extends LocalManualCache<K, V>
                                         implements LoadingCache<K, V> {

        LocalLoadingCache(CacheBuilder<? super K, ? super V> builder,
                          CacheLoader<? super K, V> loader) {
            super(new LocalCache<K, V>(builder, checkNotNull(loader)));
        }

说明：在该内部类的无参构造器的调用中，

1）首先要保证传入的CacheLoader实例非空，

2）其次创建了一个LocalCache的实例出来，

3）最后调用父类LocalManualCache的私有构造器将第二步创建出来的LocalCache实例赋给LocalCache的类变量，完成初始化。

这里最重要的就是第二步，下面着重讲第二步：

LocalCache的一些属性

    /** 最大容量（2的30次方），即最多可存放2的30次方个entry（key-value） */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /** 最多多少个Segment（2的16次方）*/
    static final int MAX_SEGMENTS = 1 << 16;

    /** 用于选择Segment */
    final int segmentMask;

    /** 用于选择Segment，尽量将hash打散 */
    final int segmentShift;

    /** 底层数据结构，就是一个Segment数组，而每一个Segment就是一个hashtable */
    final Segment<K, V>[] segments;

    /**
     * 并发水平，这是一个用于计算Segment个数的一个数，
     * Segment个数是一个刚刚大于或等于concurrencyLevel的数
     */
    final int concurrencyLevel;

    /** 键的引用类型（strong、weak、soft） */
    final Strength keyStrength;

    /** 值的引用类型（strong、weak、soft） */
    final Strength valueStrength;

    /** The maximum weight of this map. UNSET_INT if there is no maximum.
     * 如果没有设置，就是-1
     */
    final long maxWeight;

    final long expireAfterAccessNanos;

    final long expireAfterWriteNanos;

    /** Factory used to create new entries. */
    final EntryFactory entryFactory;

    /** 默认的缓存加载器，用于做一些缓存加载操作（其实就是load）,实现三步原子操作*/
    @Nullable
    final CacheLoader<? super K, V> defaultLoader;

    /** 默认的缓存加载器，用于做一些缓存加载操作（其实就是load）,实现三步原子操作*/
    @Nullable
    final CacheLoader<? super K, V> defaultLoader;

说明：关于这些属性的含义，看注释+CacheBuilder部分的属性注释+ConcurrentHashMap的属性注释

LocalCache-->LocalCache(CacheBuilder, CacheLoader)

    /**
     * 创建一个新的、空的map（并且指定策略、初始化容量和并发水平）
     */
    LocalCache(CacheBuilder<? super K, ? super V> builder,
               @Nullable CacheLoader<? super K, V> loader) {
        /*
         * 默认并发水平是4，即四个Segment（但要注意concurrencyLevel不一定等于Segment个数）
         * Segment个数：一个刚刚大于或等于concurrencyLevel且是2的几次方的一个数
         */
        concurrencyLevel = Math
                .min(builder.getConcurrencyLevel(), MAX_SEGMENTS);

        keyStrength = builder.getKeyStrength();//默认为Strong，即强引用
        valueStrength = builder.getValueStrength();//默认为Strong，即强引用

        // 缓存超时(时间起点：entry的创建或替换（即修改）)
        expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
        // 缓存超时(时间起点：entry的创建或替换（即修改）或最后一次访问)
        expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
        //创建entry的工厂
        entryFactory = EntryFactory.getFactory(keyStrength,
                                                  usesAccessEntries(),
                                                  usesWriteEntries());
        //默认的缓存加载器
        defaultLoader = loader;

        // 初始化容量为16，整个cache可以放16个缓存entry
        int initialCapacity = Math.min(builder.getInitialCapacity(),
                                       MAXIMUM_CAPACITY);

        int segmentShift = 0;
        int segmentCount = 1;
        //循环条件的&&后边的内容是关于weight的，由于没有设置maxWeight，所以其值为-1-->evictsBySize()返回false
        while (segmentCount < concurrencyLevel
                && (!evictsBySize() || segmentCount * 20 <= maxWeight)) {
            ++segmentShift;
            segmentCount <<= 1;//找一个刚刚大于或等于concurrencyLevel的Segment数
        }
        this.segmentShift = 32 - segmentShift;
        segmentMask = segmentCount - 1;

        this.segments = newSegmentArray(segmentCount);//创建指定大小的数组

        int segmentCapacity = initialCapacity / segmentCount;//计算每一个Segment中的容量的值，刚刚大于等于initialCapacity/segmentCount
        if (segmentCapacity * segmentCount < initialCapacity) {
            ++segmentCapacity;
        }

        int segmentSize = 1;//每一个Segment的容量
        while (segmentSize < segmentCapacity) {
            segmentSize <<= 1;//刚刚>=segmentCapacity&&是2的几次方的数
        }

        if (evictsBySize()) {//由于没有设置maxWeight，所以其值为-1-->evictsBySize()返回false
            // 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());
            }
        }
    }

说明：这里的代码就是整个LocalCache实例的创建过程，非常重要！！！

下面介绍在LocalCache(CacheBuilder, CacheLoader)中调用的一些方法：

• CacheBuilder-->getConcurrencyLevel()

  int getConcurrencyLevel() {
          return (concurrencyLevel == UNSET_INT) ? //是否设置了concurrencyLevel
                  DEFAULT_CONCURRENCY_LEVEL//如果没有设置，采用默认值16
                  : concurrencyLevel;//如果设置了，采用设置的值
      }

  说明：检查是否设置了concurrencyLevel，如果设置了，采用设置的值，如果没有设置，采用默认值16

• CacheBuilder-->getKeyStrength()

  //获取键key的强度（默认为Strong，还有weak和soft）
      Strength getKeyStrength() {
          return MoreObjects.firstNonNull(keyStrength, Strength.STRONG);
      }

  说明：获取key的引用类型（强度），默认为Strong（强引用类型），下表列出MoreObjects的方法firstNonNull(@Nullable T first, @Nullable T second)

  public static <T> T firstNonNull(@Nullable T first, @Nullable T second) {
      return first != null ? first : checkNotNull(second);
    }

• CacheBuilder-->getValueStrength()

      Strength getValueStrength() {
          return MoreObjects.firstNonNull(valueStrength, Strength.STRONG);
      }

  说明：获取value的引用类型（强度），默认为Strong（强引用类型）

• CacheBuilder-->getExpireAfterWriteNanos()

  long getExpireAfterWriteNanos() {
          return (expireAfterWriteNanos == UNSET_INT) ?
                  DEFAULT_EXPIRATION_NANOS
                  : expireAfterWriteNanos;
      }

  说明：获取超时时间，如果设置了，就是设置值，如果没设置，默认是0

• CacheBuilder-->getInitialCapacity()

  int getInitialCapacity() {
          return (initialCapacity == UNSET_INT) ?
                  DEFAULT_INITIAL_CAPACITY
                  : initialCapacity;
      }

  说明：获取初始化容量，如果指定了就是用指定容量，如果没指定，默认为16。值得注意的是，该容量是用于计算每个Segment的容量的，并不一定是每个Segment的容量，其具体使用的方法见LocalCache(CacheBuilder, CacheLoader)

• LocalCache-->evictsBySize()

  //这里maxWeight没有设置值，默认为UNSET_INT,即-1
  
      boolean evictsBySize() {
          return maxWeight >= 0;
      }

  说明：这是一个与weight相关的方法，由于我们没有设置weight，所以该方法对我们的程序没有影响。

• EntryFactory-->getFatory()

  /**
           * Masks used to compute indices in the following table.
           */
          static final int ACCESS_MASK = 1;
          static final int WRITE_MASK = 2;
          static final int WEAK_MASK = 4;
  
          /**
           * Look-up table for factories.
           */
          static final EntryFactory[] factories = { STRONG, STRONG_ACCESS,
                  STRONG_WRITE, STRONG_ACCESS_WRITE, WEAK, WEAK_ACCESS,
                  WEAK_WRITE, WEAK_ACCESS_WRITE, };
  
          static EntryFactory getFactory(Strength keyStrength,
                                         boolean usesAccessQueue,
                                         boolean usesWriteQueue) {
              int flags = ((keyStrength == Strength.WEAK) ? WEAK_MASK : 0)//
                      | (usesAccessQueue ? ACCESS_MASK : 0)//
                      | (usesWriteQueue ? WRITE_MASK : 0);//WRITE_MASK-->2
              return factories[flags];//STRONG_WRITE
          }

  说明：EntryFactory是LocalCache的一个内部枚举类，通过上述方法，获取除了相应的EntryFactory，这里选出的是STRONG_WRITE工厂，该工厂代码如下：

          STRONG_WRITE {
              /**
               * 创建新的Entry
               */
              @Override
              <K, V> ReferenceEntry<K, V> newEntry(Segment<K, V> segment,
                                                   K key,
                                                   int hash,
                                                   @Nullable ReferenceEntry<K, V> next) {
                  return new StrongWriteEntry<K, V>(key, hash, next);
              }
  
              /**
               * 将原来的Entry（original）拷贝到当下的Entry（newNext）
               */
              @Override
              <K, V> ReferenceEntry<K, V> copyEntry(Segment<K, V> segment,
                                                    ReferenceEntry<K, V> original,
                                                    ReferenceEntry<K, V> newNext) {
                  ReferenceEntry<K, V> newEntry = super.copyEntry(segment,
                          original, newNext);
                  copyWriteEntry(original, newEntry);
                  return newEntry;
              }
          }

  在该工厂中，指定了创建新entry的方法与复制原有entry为另一个entry的方法。

• LocalCache-->newSegmentArray(int ssize)

  /**
       * 创建一个指定大小的Segment数组
       */
      @SuppressWarnings("unchecked")
      final Segment<K, V>[] newSegmentArray(int ssize) {
          return new Segment[ssize];
      }

  说明：该方法用于创建一个指定大小的Segment数组。关于Segment的介绍后边会说。

• LocalCache-->createSegment(initialCapacity,maxSegmentWeight,StatsCounter)

      Segment<K, V> createSegment(int initialCapacity,
                                  long maxSegmentWeight,
                                  StatsCounter statsCounter) {
          return new Segment<K, V>(this,
                                   initialCapacity,
                                   maxSegmentWeight,
                                   statsCounter);
      }

  该方法用于为之前创建的Segment数组的每一个元素赋值。

  下边列出Segment类的一些属性和方法：

  final LocalCache<K, V> map;// 外部类的一个实例
  
          /** 该Segment中已经存在缓存的个数  */
          volatile int count;
  
          /**
           * 指定是下边的AtomicReferenceArray<ReferenceEntry<K, V>> table，即扩容也是只扩自己的Segment
           * The table is expanded when its size exceeds this threshold. (The
           * value of this field is always {@code (int) (capacity * 0.75)}.)
           */
          int threshold;
  
          /**
           * 每个Segment中的table
           */
          volatile AtomicReferenceArray<ReferenceEntry<K, V>> table;
  
          /**
           * The maximum weight of this segment. UNSET_INT if there is no maximum.
           */
          final long maxSegmentWeight;
  
          /**
           * map中当前元素的一个队列，队列元素根据write time进行排序，每write一个元素就将该元素加在队列尾部
           */
          @GuardedBy("this")
          final Queue<ReferenceEntry<K, V>> writeQueue;
  
          /**
           * A queue of elements currently in the map, ordered by access time.
           * Elements are added to the tail of the queue on access (note that
           * writes count as accesses).
           */
          @GuardedBy("this")
          final Queue<ReferenceEntry<K, V>> accessQueue;
  
          Segment(LocalCache<K, V> map, int initialCapacity,
                  long maxSegmentWeight, StatsCounter statsCounter) {
              this.map = map;
              this.maxSegmentWeight = maxSegmentWeight;//
              this.statsCounter = checkNotNull(statsCounter);
              initTable(newEntryArray(initialCapacity));
  
              writeQueue = map.usesWriteQueue() ? //过期时间>0
                           new WriteQueue<K, V>() //WriteQueue
                           : LocalCache.<ReferenceEntry<K, V>> discardingQueue();
  
              accessQueue = map.usesAccessQueue() ? //false
                            new AccessQueue<K, V>()
                            : LocalCache.<ReferenceEntry<K, V>> discardingQueue();
          }
  
          AtomicReferenceArray<ReferenceEntry<K, V>> newEntryArray(int size) {
              return new AtomicReferenceArray<ReferenceEntry<K, V>>(size);//new Object[size];
          }
  
          void initTable(AtomicReferenceArray<ReferenceEntry<K, V>> newTable) {
              this.threshold = newTable.length() * 3 / 4; // 0.75
              if (!map.customWeigher() && this.threshold == maxSegmentWeight) {
                  // prevent spurious expansion before eviction
                  this.threshold++;
              }
              this.table = newTable;
          }

  Segment的构造器完成了三件事儿：为变量复制 + 初始化Segment的table + 构建相关队列

  • initTable(newEntryArray(initialCapacity))源代码在Segment类中已给出：初始化table的步骤简述为：创建一个指定个数的ReferenceEntry数组，计算扩容值。
  • 其他队列不说了，这里实际上只用到了WriteQueue，建立该Queue的目的是用于实现LRU缓存回收算法

到目前为止，guava cache的完整的一个数据结构基本上就建立起来了。最后再总结一下。

guava cache的数据结构：

guava cache的数据结构的构建流程：

1）构建CacheBuilder实例cacheBuilder

2）cacheBuilder实例指定缓存器LocalCache的初始化参数

3）cacheBuilder实例使用build()方法创建LocalCache实例（简单说成这样，实际上复杂一些）

3.1）首先为各个类变量赋值（通过第二步中cacheBuilder指定的初始化参数以及原本就定义好的一堆常量）

3.2）之后创建Segment数组

3.3）最后初始化每一个Segment[i]

3.3.1）为Segment属性赋值

3.3.2）初始化Segment中的table，即一个ReferenceEntry数组（每一个key-value就是一个ReferenceEntry）

3.3.3）根据之前类变量的赋值情况，创建相应队列，用于LRU缓存回收算法

这里，我们就用开头给出的代码实例，来看一下，最后构建出来的cache结构是个啥：

显示指定：

expireAfterWriteNanos==20min   maximumSize==1000

默认值：

concurrency_level==4（用于计算Segment个数）     initial_capcity==16 （用于计算每个Segment容量）

keyStrength==STRONG  　　valueStrength==STRONG

计算出：

entryFactory==STRONG_WRITE

segmentCount==4：Segment个数，一个刚刚大于等于concurrency_level且是2的几次方的一个数

segmentCapacity==initial_capcity/segmentCount==4：用来计算每个Segment能放置的entry个数的一个值，一个刚刚等于initial_capcity/segmentCount或者比initial_capcity/segmentCount大1的数（关键看是否除尽）

segmentSize==4：每个Segment能放置的entry个数，刚刚>=segmentCapacity&&是2的几次方的数

segments==Segment[segmentCount]==Segment[4]

segments[i]：

• 包含一个ReferenceEntry[segmentSize]==ReferenceEntry[4]
• WriteQueue：用于LRU算法的队列
• threshold==newTable.length()*3/4==segmentSize*3/4==3：每个Segment中有了3个Entry（key-value），就会扩容，扩容机制以后在添加Entry的时候再讲