Google Guava Cache 详解

Google Guava Cache是一种非常优秀本地缓存解决方案，提供了基于容量，时间和引用的缓存回收方式。基于容量的方式内部实现采用LRU算法，基于引用回收很好的利用了Java虚拟机的垃圾回收机制。其中的缓存构造器CacheBuilder采用构建者模式提供了设置好各种参数的缓存对象，缓存核心类LocalCache里面的内部类Segment与jdk1.7及以前的ConcurrentHashMap非常相似，都继承于ReetrantLock，还有六个队列，以实现丰富的本地缓存方案。
本文先介绍了Guava Cache囊括的基本使用方法，然后结合体系类图和LocalCache的数据结构对典型的几个方法源码进行流程分析。

为什么要用本地缓存

相对于IO操作
速度快，效率高
相对于Redis
Redis是一种优秀的分布式缓存实现，受限于网卡等原因，远水救不了近火。

DB + Redis + LocalCache = 高效存储，高效访问

image

什么时候用

• 愿意消耗一些内存空间来提升速度

• 预料到某些键会被多次查询

• 缓存中存放的数据总量不会超出内存容量

怎么用

1. 设置缓存容量

2. 设置超时时间

3. 提供移除监听器

4. 提供缓存加载器

5. 构建缓存

Demo1:

<pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo1 {
public static void main(String[] args){
CacheLoader<String, String> loader = new CacheLoader<String, String> () {
public String load(String key) throws Exception {
Thread.sleep(1000); if("key".equals(key)) return null;
System.out.println(key + " is loaded from a cacheLoader!"); return key + "'s value";
}
};

    RemovalListener<String, String> removalListener = new RemovalListener<String, String>() {
        public void onRemoval(RemovalNotification<String, String> removal) {
            System.out.println("[" + removal.getKey() + ":" + removal.getValue() + "] is evicted!");
        }
    };

    LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .maximumSize(7)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .removalListener(removalListener)
            .build(loader);        for (int i = 0; i < 10; i ++){            String key = "key" + i;            String value = "value" + i;
        testCache.put(key,value);
        System.out.println("[" + key + ":" + value + "] is put into cache!");
    }

    System.out.println(testCache.getIfPresent("key6"));        try{
        System.out.println(testCache.get("key"));
    }        catch(Exception e){
        e.printStackTrace();
    }
}

}</pre>

运行效果：

image

加载

CacheLoader

如果有合理的默认方法来加载或计算与键关联的值。

LoadingCache是附带CacheLoader构建而成的缓存实现。创建自己的CacheLoader通常只需要简单地实现V load(K key) throws Exception方法。

从LoadingCache查询的正规方式是使用get(K)方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值。由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明为抛出ExecutionException异常。

Callable

如果没有合理的默认方法来加载或计算与键关联的值，或者想要覆盖默认的加载运算，同时保留“获取缓存-如果没有-则计算”[get-if-absent-compute]的原子语义。
所有类型的Guava Cache，不管有没有自动加载功能，都支持get(K, Callable<V>)方法。这个方法返回缓存中相应的值，或者用给定的Callable运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式"如果有缓存则返回；否则运算、缓存、然后返回"。

Demo2:

<pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo2 { static Cache<String, String> testCache = CacheBuilder.newBuilder()
.maximumSize(3)
.build(); public static void main(String[] args){
testCache.put("1234","45");

    System.out.println(testCache.getIfPresent("key6"));        try {

        System.out.println(testCache.get("123", new Callable<String>() {                public String call() throws Exception {                    return "134";
            }
        }));

        System.out.println(testCache.get("1234", new Callable<String>() {                public String call() throws Exception {                    return "134";
            }
        }));
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

}</pre>

运行效果：

image

Cache.put

但自动加载是首选的，因为它可以更容易地推断所有缓存内容的一致性。
使用cache.put(key, value)方法可以直接向缓存中插入值，这会直接覆盖掉给定键之前映射的值。使用Cache.asMap()视图提供的任何方法也能修改缓存。但请注意，asMap视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说，asMap视图的原子运算在Guava Cache的原子加载范畴之外，所以相比于Cache.asMap().putIfAbsent(K,V)，Cache.get(K, Callable<V>) 应该总是优先使用。

缓存回收

Guava Cache提供了三种基本的缓存回收方式:

1. 基于容量回收

maximumSize(long)：当缓存中的元素数量超过指定值时。

2. 定时回收

expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。
如下文所讨论，定时回收周期性地在写操作中执行，偶尔在读操作中执行。

3. 基于引用回收（Reference-based Eviction）

CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。
CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。
CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。

显式清除

任何时候，你都可以显式地清除缓存项，而不是等到它被回收：
个别清除：Cache.invalidate(key)
批量清除：Cache.invalidateAll(keys)
清除所有缓存项：Cache.invalidateAll()

移除监听器

通过CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener会获取移除通知[RemovalNotification]，其中包含移除原因[RemovalCause]、键和值。

统计

CacheBuilder.recordStats()：用来开启Guava Cache的统计功能。统计打开后，Cache.stats()方法会返回CacheS tats 对象以提供如下统计信息：

hitRate()：缓存命中率；
averageLoadPenalty()：加载新值的平均时间，单位为纳秒；
evictionCount()：缓存项被回收的总数，不包括显式清除。
此外，还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中我们建议密切关注这些数据。

Demo3:

<pre style="margin: 25px 0px 0.8em; padding: 10px; font-family: Menlo, Monaco, Consolas, "Courier New", monospace; display: block; font-size: 0.92857em; line-height: 1.3; color: rgb(51, 51, 51); word-break: break-all; overflow-wrap: break-word; border-radius: 4px; background-color: rgb(243, 243, 243); position: relative; border: none; overflow: auto; text-indent: 0px;">public class GuavaCacheDemo3 { static Cache<String, Object> testCache = CacheBuilder.newBuilder()
.weakValues()
.recordStats()
.build();

public static void main(String[] args){        Object obj1 = new Object();

    testCache.put("1234",obj1);

    obj1 = new String("123");

    System.gc();

    System.out.println(testCache.getIfPresent("1234"));

    System.out.println(testCache.stats());

}

}</pre>

运行结果

image

LRU缓存回收算法

LRU（Least?recently?used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

image

1.?新数据插入到链表头部；
2.?每当缓存命中（即缓存数据被访问），则将数据移到链表头部；
3.?当链表满的时候，将链表尾部的数据丢弃。

Guava Cache中借助读写队列来实现LRU算法。

Guava Cache体系类图

image

CacheBuilder

缓存构建器。构建缓存的入口，指定缓存配置参数并初始化本地缓存。
主要采用builder的模式，CacheBuilder的每一个方法都返回这个CacheBuilder知道build方法的调用。
注意build方法有重载，带有参数的为构建一个具有数据加载功能的缓存，不带参数的构建一个没有数据加载功能的缓存。

LocalManualCache

作为LocalCache的一个内部类，在构造方法里面会把LocalCache类型的变量传入，并且调用方法时都直接或者间接调用LocalCache里面的方法。

LocalLoadingCache

可以看到该类继承了LocalManualCache并实现接口LoadingCache。
覆盖了get，getUnchecked等方法。

LocalCache

Guava Cache中的核心类，重点了解。

LocalCache数据结构

根据上面的分析可知，LocalCache为Guava Cache的核心类，先看一个该类的数据结构： � LocalCache的数据结构与ConcurrentHashMap很相似，都由多个segment组成，且各segment相对独立，互不影响，所以能支持并行操作。每个segment由一个table和若干队列组成。缓存数据存储在table中，其类型为AtomicReferenceArray。

image

Segment<K, V>[] segments;

Segment继承于ReetrantLock，减小锁粒度，提高并发效率。

AtomicReferenceArray<ReferenceEntry<K, V>> table;

类似于HasmMap中的table一样，相当于entry的容器。

ReferenceEntry<K, V> referenceEntry;

基于引用的Entry,其实现类有弱引用Entry,强引用Entry等

ReferenceQueue<K> keyReferenceQueue;

已经被GC，需要内部清理的键引用队列。

ReferenceQueue<V> valueReferenceQueue;

已经被GC，需要内部清理的值引用队列。

Queue<ReferenceEntry<K, V>> recencyQueue;

记录升级可访问列表清单时的entries,当segment上达到临界值或发生写操作时该队列会被清空。

Queue<ReferenceEntry<K, V>> writeQueue;

按照写入时间进行排序的元素队列，写入一个元素时会把它加入到队列尾部。

Queue<ReferenceEntry<K, V>> accessQueue;

按照访问时间进行排序的元素队列，访问(包括写入)一个元素时会把它加入到队列尾部。

put

public V put(K key, V value); //onlyIfAbsent为false
public V putIfAbsent(K key, V value); //onlyIfAbsent为true
该方法显式往本地缓存里面插入值。从下面的流程图中可以看出，在执行每次put前都会进行preWriteCleanUP，在put返回前如果更新了entry则要进行evictEntries操作。

image

preWriteCleanup

void preWriteCleanup(long now)；
传人参数只有当前时间。
键值引用队列中都是存储已经被GC，等待清除的entry信息，所以首先去处理这个里面的entry.
读写队列里面是按照读写时间排序的，取出队列中的首元素，如果当前时间与该元素的时间相差值大于设定值，则进行回收。

image

evictEntries

void evictEntries(ReferenceEntry<K, V> newest)；
传入的参数为最新的Entry，可能是刚插入的，也可能是刚更新过的。
该方法只有在设置了在构建缓存的时候指定了maximumSize才会往下执行。首先清除recencyQueue，判断该元素自身的权重是否超过上限，如果超过则移除当前元素。然后判断总的权重是否大于上限，如果超过则去accessQueue里找到队首(即最不常访问的元素)进行移除，直到小于上限。

image

getIfPresent

public V getIfPresent(Object key)；
该方法从本地缓存中找值，如果找不到返回null，找到就返回相应的值。

image

get

首先会在缓存中找，缓存中找不到再通过load加载。

image

remove

public V remove(@Nullable Object key)；
调用LocalManualCache的invalidate(Object key)方法即可调用remove.

原文链接：https://www.jianshu.com/p/38bd5f1cf2f2