本讲主要针对本地 Cache 的老大哥 Guava Cache 进行介绍和分析，会选取本地缓存和分布式缓存（NoSQL）的优秀框架比较他们各自的优缺点、应用场景、项目中的最佳实践以及原理分析。

一、Guava Cache介绍

        Guava Cache 是 google 开源的一款本地缓存工具库，它的设计灵感来源于ConcurrentHashMap，使用多个 segments 方式的细粒度锁，在保证线程安全的同时，支持高并发场景需求，同时支持多种类型的缓存清理策略，包括基于容量的清理、基于时间的清理、基于引用的清理等。

        传统的JVM 缓存，是堆缓存，其实就是创建一些全局容器，比如：List、Set、Map等。这些容器用来做数据存储还可以，却不能按照一定的规则淘汰数据，如 LRU，LFU，FIFO 等，也没有清除数据时的回调通知，而且多线程不安全。虽然针对高并发可以使用CurrentHashMap，但是过期处理和数据刷新都需要手动完成。

        相比较而言，同样是基于 JVM 缓存的 Guava Cache 就显得优势明显，且很有必要：

1. 缓存过期和淘汰机制

        在Guava Cache中可以设置Key的过期时间，包括访问过期和创建过期Guava Cache在缓存容量达到指定大小时，采用LRU的方式，将不常使用的键值从Cache中删除；

2. 并发处理能力

        Guava Cache类似CurrentHashMap，是线程安全的。它提供了设置并发级别的API，使得缓存支持并发的写入和读取；

        像ConcurrentHashMap结构类似，GuavaCache也使用Segment做分区，采用分离锁机制，分离锁能够减小锁力度，提升并发能力分离锁是分拆锁定，把一个集合看分成若干partition, 每个partiton一把锁。ConcurrentHashMap就是分了16个区域，这16个区域之间是可以并发的。

3. 更新锁定

        一般情况下，在缓存中查询某个key，如果不存在，则查源数据，并回填缓存。在高并发下会出现，多次查源并重复回填缓存，可能会造成源的宕机（DB），性能下降 Guava Cache 可以在 CacheLoader 的load方法中加以控制，对同一个key，只让一个请求去读源并回填缓存，其他请求阻塞等待。

4. 集成数据源

        一般我们在业务中操作缓存，都会操作缓存和数据源两部分。Guava Cache 的 get 可以集成数据源，在从缓存中读取不到时，可以从数据源中读取数据并回填缓存。

5. 监控缓存加载/命中情况

        既然是缓存服务，那统计数据的功能自然也是少不了。

二、基本用法

Guava Cache 的 maven 依赖：

<dependency>
		<groupId>com.google.guava</groupId>
		<artifactId>guava</artifactId>
		<version>21.0</version>
</dependency>

2.1 构建Cache对象

2.1.3 CacheLoader和Callable的区别

        CacheLoader 和 Callable 都实现了一种逻辑：先取缓存，如果取不到相关key对应的内容，再执行 load 或者 call 方法中自己实现的逻辑来获取相关数据并缓存起来，不同点是：

• CacheLoader 是按 key 统一加载，所有取不到的统一执行一种 load 逻辑；
• Callable 方法允许在 get 的时候指定 key，传入一个Callable实例并实现加载逻辑。

2.2 CacheBuilder参数介绍

CacheBuilder是一个用于构建Cache的类，是建造者模式的一个例子，主要的方法有：

1. maximumSize(long maximumSize)：设置缓存存储的所有元素的最大个数。（慎重设置）
2. maximumWeight(long maximumWeight)：设置缓存存储的所有元素的最大权重。
3. expireAfterAccess(long duration, TimeUnit unit)：设置元素在最后一次访问多久后过期。
4. expireAfterWrite(long duration, TimeUnit unit)：设置元素在写入缓存后多久过期。
5. concurrencyLevel(int concurrencyLevel)：设置并发水平，即允许多少线程无冲突的访问Cache，默认值是4，该值越大，LocalCache中的segment数组也会越大，访问效率越高，当然空间占用也大一些。
6. removalListener(RemovalListener<? super K1, ? super V1> listener)：设置元素删除通知器，在任意元素无论何种原因被删除时会调用该通知器。
7. setKeyStrength(Strength strength)：设置元素的key是强引用，还是弱引用，默认强引用，并且该属性也指定了EntryFactory使用是强引用还是弱引用。
8. setValueStrength(Strength strength)：设置元素的value是强引用，还是弱引用，默认强引用。

2.3 get和put

Cache的存放数据的方法只有一种，和map一样：put(K，V)；拿取的方法有三种，区别如下：

1. get(K)：使用这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值。由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明为抛出ExecutionException异常。如果你定义的CacheLoader没有声明任何检查型异常，则可以通过 getUnchecked(K) 查找缓存；但必须注意，一旦CacheLoader声明了检查型异常，就不可以调用getUnchecked(K)。
2. getIfPresent(key)：从现有的缓存中获取，如果缓存中有key，则返回value，如果没有则返回null，不加载load（）方法；
3. getAll(Iterable<? extends K>)：用来执行批量查询。默认情况下，对每个不在缓存中的键，getAll方法会单独调用CacheLoader.load来加载缓存项。可以通过重写 load（）方法来提高加载缓存的效率；

2.4 自动加载

        Cache的get方法有两个参数，第一个参数是要从Cache中获取记录的key，第二个记录是一个Callable对象。

        当缓存中已经存在key对应的记录时，get方法直接返回key对应的记录。如果缓存中不包含key对应的记录，Guava会启动一个线程执行Callable对象中的call方法，call方法的返回值会作为key对应的值被存储到缓存中，并且被get方法返回。

        Guava可以保证当有多个线程同时访问Cache中的一个key时，如果key对应的记录不存在，Guava只会启动一个线程执行get方法中Callable参数对应的任务加载数据存到缓存。当加载完数据后，任何线程中的get方法都会获取到key对应的值。

String value = cache.get("key", new Callable<String>() {
    public String call() throws Exception {
        // 在这里写从DB获取数据的方法并返回
        // 模拟加载时间
        Thread.sleep(1000);                 
        return "auto load by Callable";
    }
});

2.5 缓存回收策略

不管是磁盘也好，内存也罢，我们的空间都不是无限的。所以，我们必须决定：什么时候某个缓存项就不值得保留了。

Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收和基于引用回收。

2.5.1 基于容量的回收

如果要规定缓存项的数目不超过固定值，只需使用CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。

警告：在缓存项的数目达到限定值之前，缓存就可能进行回收操作，通常来说，这种情况发生在缓存项的数目逼近限定值时。

Cache<String,String> cache = CacheBuilder.newBuilder()
        .maximumSize(2)
        .build();
        
cache.put("key1","value1");
cache.put("key2","value2");
System.out.println("第一个值：" + cache.getIfPresent("key1"));
System.out.println("第二个值：" + cache.getIfPresent("key2"));

cache.put("key3","value3");
System.out.println("第一个值：" + cache.getIfPresent("key1"));
System.out.println("第二个值：" + cache.getIfPresent("key2"));
System.out.println("第三个值：" + cache.getIfPresent("key3"));

结果：
第一个值：value1
第二个值：value2
第一个值：null
第二个值：value2
第三个值：value3

2.5.2 定时回收

CacheBuilder提供两种定时回收的方法：

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

定时回收在周期性地在写操作中执行，偶尔在读操作中执行。

2.5.3 基于引用的回收

通过weakKeys和weakValues方法指定Cache只保存对缓存记录key和value的弱引用。这样当没有其他强引用指向key和value时，key和value对象就会被垃圾回收器回收。

• CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。
• CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用值的缓存用==而不是equals比较值。
• CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。

Cache<String,Object> cache = CacheBuilder.newBuilder()
            .maximumSize(2)
            .weakValues()
            .build();

2.6 主动清除

可以调用Cache的 invalidate 或 invalidateAll 方法显示删除Cache中的记录。

• invalidate方法：一次只能删除Cache中一个记录，接收的参数是要删除记录的key。
• invalidateAll方法：可以批量删除Cache中的记录，当没有传任何参数时，invalidateAll方法将清除Cache中的全部记录。invalidateAll也可以接收一个Iterable类型的参数，参数中包含要删除记录的所有key值。

Cache<String,String> cache = CacheBuilder.newBuilder().build();
Object value = new Object();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");

// 1.清除指定的key
cache.invalidate("key1");

// 2.批量清除list中全部key对应的记录
List<String> list = new ArrayList<String>();
list.add("key1");
list.add("key2");
cache.invalidateAll(list);

2.7 移除动作监听器

可以为Cache对象添加一个移除监听器，这样当有记录被删除时可以感知到这个事件。

RemovalListener<String, String> listener = new RemovalListener<String, String>() {
    public void onRemoval(RemovalNotification<String, String> notification) {
        System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
    }
};
Cache<String,String> cache = CacheBuilder.newBuilder()
        .maximumSize(3)
        .removalListener(listener)
        .build();

2.8 统计信息

可以对Cache的命中率、加载数据时间等信息进行统计。在构建Cache对象时，可以通过CacheBuilder的recordStats方法开启统计信息的开关。开关开启后Cache会自动对缓存的各种操作进行统计，调用Cache的stats方法可以查看统计后的信息。

Cache<String,String> cache = CacheBuilder.newBuilder()
            .maximumSize(3)
            .recordStats() //开启统计信息开关
            .build();
System.out.println(cache.stats()); //获取统计信息

三、缓存项加载机制

        如果某个缓存过期了或者缓存项不存在于缓存中，而恰巧此此时有大量请求过来请求这个缓存项，如果没有保护机制就会导致大量的线程同时请求数据源加载数据并生成缓存项，就算某一个线程率先获取到数据生成了缓存项，其他的线程还是继续请求 DB 而不会走到缓存，这就是所谓的 “缓存击穿” 。

四、缓存项刷新机制

缓存项的刷新和加载看起来是相似的，都是让缓存数据处于最新的状态。区别在于：

        由于缓存项刷新的前提是该缓存项存在于缓存中，那么缓存的刷新就不用像缓存加载的流程一样让其他线程等待而是允许一个线程去数据源获取数据，其他线程都先返回老值直到异步线程生成了新缓存项。

        这个方案完美解决了上述遇到的 “缓存击穿” 问题，不过他的前提是已经生成缓存项了。在实际生产情况下我们可以做 缓存预热 ，提前生成缓存项，避免流量洪峰造成的线程堆积。

private static final LoadingCache<String, String> ASYNC_CACHE = CacheBuilder.newBuilder()
    .build(
        CacheLoader.asyncReloading(new CacheLoader<String, String>() {
    
        @Override
        public String load(String key) {
            return key;
        }

        @Override
        public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
            return super.reload(key, oldValue);
        }
    }, new ThreadPoolExecutor(5, Integer.MAX_VALUE,
    60L, TimeUnit.SECONDS,
    new SynchronousQueue<>()))
);

        回顾下 Get 的流程以及在每个阶段做的事情，返回的值。首先判断缓存是否过期然后判断是否需要刷新，如果过期了就调用 loading 去同步加载数据（其他线程阻塞），如果是仅仅需要刷新调用 reloading 异步加载（其他线程返回老值）。

        注意，如果 refreshTime > expireTime 意味着永远走不到缓存刷新逻辑，缓存刷新是为了在缓存有效期内尽量保证缓存数据一致性，所以，在配置刷新策略和过期策略时一定保证 refreshTime < expireTime 。

最后关于 Guava Cache 的使用建议 (最佳实践) ：