一、概述

guava⽬前有三种刷新本地缓存的机制：
expireAfterAccess：当缓存项在指定的时间段内没有被读或写就会被回收。
expireAfterWrite：当缓存项在指定的时间段内没有更新就会被回收。-- 常用
refreshAfterWrite：当缓存项上一次更新操作之后的多久会被刷新。 -- 常用

二、原理

expireAfterWrite 为了避免缓存雪崩，guava 会限制只有一个加载操作时进行加锁，其他请求必须阻塞等待这个加载操作完成。而且，在加载完成之后，其他请求的线程会逐一获得锁，去判断是否已被加载完成，每个线程必须轮流地走一个“获得锁，获得值，释放锁”的过程，这样性能会有一些损耗。详情请参考LocalCache类

refreshAfterWrite 当缓存项上一次更新操作之后的多久会被刷新。在 refresh 的过程中，guava 会限制只有一个加载操作时进行加锁，而其他查询先返回旧值，这样能有效减少等待和锁争用，所以 refreshAfterWrite 会比 expireAfterWrite 性能好。

Load 加锁是从从 expire 到 load 到新值为⽌，⽽ refresh->reload 的过程，⼀旦 get 发现需要 refresh，会先判断是否有 loading，再去获得锁，然后释放锁之后再去reload，阻塞的范围只是 insertLoadingValueReference 的⼀个⼩对象的 new 和 set 操作，⼏乎可以忽略不计

三、代码实践

首先了解⼀个机制，guava 不会⾃动清除清除数据，只有在访问时候再去判断 expire

设置合理的 expireAfterWrite 和 refreshAfterWrite 时间来保证缓存不会被瞬间击垮。根据合理的场景设置合理的参数。

比如 expireAfterWrite=60 和 refreshAfterWrite=30，保证每隔 30 秒刷新⼀次数据。但是超过 60 秒⼀直没有访问量，突然间访问，还是会触发 load 操作。

expireAfterWrite 是为了保证在很久没有访问量，⾸次访问不再访问旧值。⽐如已经间隔⼀天，首次访问希望获取最新值，而不是先获取旧值再去刷新新值，这种就可⽤通过设置expireAfterWrite来保证。

其实如果极端情况下，即新旧值基本不会变更的，直接不采⽤ expireAfterWrite，⽽直接采⽤ refreshAfterWrite 来执⾏ load 也是可以的，性能会更优

使用注意：请注意：如果每次去取值的时候希望走load方法 要使用get() 而不是getIfPresent()

但是get方法会抛出异常需要捕捉处理，getIfPersent如果不存在就返回空值，但是不会走load方法去主动填充缓存。

Maven版本依赖

      <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.0.1-jre</version>
        </dependency>

package com.example.demo.dto;

import com.google.common.cache.*;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author lisanwei24282
 */
@Slf4j
public class CacheBuilderTest {

    /**
     * 自增
     */
    private static LongAdder ADDER = new LongAdder();

    public static void main(String[] args) throws InterruptedException {

        LoadingCache<String, String> loadingCache
                //CacheBuilder的构造函数是私有的，只能通过其静态方法newBuilder()来获得CacheBuilder的实例
                = CacheBuilder.newBuilder()
                //设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                //设置写缓存后60秒过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                //设置写缓存后30秒刷新
                .refreshAfterWrite(60, TimeUnit.MINUTES)
                //设置缓存容器的初始容量为5
                .initialCapacity(5)
                //设置缓存最大容量为100，超过100之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(100)
                //设置要统计缓存的命中率
                .recordStats()
                //设置缓存的移除通知
                .removalListener(notification -> log.info(notification.getKey() + " 被移除了，原因： " + notification.getCause()))
                //build方法中可以指定CacheLoader，在缓存不存在时通过CacheLoader的实现自动加载缓存
                .build(new CacheLoader<String, String>() {

                    @Override
                    public String load(String key) {
                        // TODO 这里是如果使用loadingCache.get(key)或者这里是如果使用loadingCache.getUnchecked(key)获取
                        // TODO 残存中数据时,如果为空，则自动会放入LoadingCache内存缓存中，return值就是放入内存缓存中的值
                        // TODO 同时设置的expireAfterWrite缓存失效策略，超过过期时间，也会自动将这个方法return数据加入放入内存缓存

                        // TODO 此处需要注意就要使用loadingCache.getIfPresent(key)不会加载load方法，就是本方法，就算使用PUT方法
                        // TODO 例如:
                        //  String lucky = (String) loadingCache.getUnchecked("lucky");
                        //  Object aa = loadingCache.getIfPresent("AA");
                        //  if (aa == null) {
                        //     loadingCache.put("AA", "A--------------------------");
                        //  } else {
                        //     System.out.println("res = " + aa);
                        //  }
                        //   System.out.println("数据库获取:" + key + ", load");
                        // TODO 此时若同时设置的expireAfterWrite缓存失效策略，超过过期时间还是放入是本方法的return结果

                        // TODO 这里可以集合数据库做数据获取，然后返回就是放入缓存数据库中的数据值
                        ADDER.increment();
                        return "Hello Guava Cache " + key + "load" + ADDER.intValue();
                    }

                });

        while (true) {
            String lucky = (String) loadingCache.getUnchecked("lucky");
            System.out.println(lucky);

            Object aa = loadingCache.getIfPresent("AA");
            if (aa == null) {
                loadingCache.put("AA", "A--------------------------");
            } else {
                System.out.println("res = " + aa);
            }

            System.out.println("缓存命中率:" + loadingCache.stats().hitCount());
            System.out.println("加载新值的平均时间，单位为毫秒:" + loadingCache.stats().averageLoadPenalty() / 10000);
            System.out.println("缓存项被回收的总数，不包括显式清除:" + loadingCache.stats().evictionCount());
            Thread.sleep(1000);
            System.out.println("---------------------------------------------------------");
        }
    }
}