1、guava cache
- 当下最常用最简单的本地缓存
- 线程安全的本地缓存
- 类似于ConcurrentHashMap(或者说成就是一个ConcurrentHashMap,只是在其上多添加了一些功能)
2、使用实例
具体在实际中使用的例子,去查看《第七章 企业项目开发--本地缓存guava cache》,下面只列出测试实例:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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多行,所以只介绍上边给出的实例部分的相关源码解析。本节只说一下缓存器的构建,即如下代码部分:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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的一些属性:
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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实例
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * 采用默认的设置(如下)创造一个新的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)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * 指明每一个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)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * 指定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)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * 建立一个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构造器
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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的一些属性
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** 最大容量(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)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
/** * 创建一个新的、空的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;//如果设置了,采用设置的值 }
- 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)//0 | (usesAccessQueue ? ACCESS_MASK : 0)//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;//0 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的时候再讲