Guava Cache 是 Guava 中的一个内存缓存模块，用于将数据缓存到 JVM 内存中。它的架构设计灵感来源于 ConcurrentHashMap，因此也是一个线程安全的键值对缓存，还提供了缓存失效策略、缓存剔除策略、缓存动态加载、监控缓存加载、命中情况等额外功能。

使用示例

public class GuavaCacheDemo {
    public static void main(String[] args) throws ExecutionException {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
            .concurrencyLevel(8)
            // 设置缓存容器的初始容量为10
            .initialCapacity(10)
            // 设置缓存最大容量为100，超过100之后就会按照LRU最近最少使用算法来移除缓存项
            .maximumSize(100)
            // 是否需要统计缓存情况，该操作消耗一定的性能，生产环境应该去除
            .recordStats()
            // 设置写缓存后n秒钟过期
            .expireAfterWrite(60, TimeUnit.SECONDS)
            // 设置读写缓存后n秒钟过期，实际很少用到，一般只使用expireAfterWrite
            .expireAfterAccess(60, TimeUnit.SECONDS)
            // 设置写缓存后n秒钟刷新对应键值对
            .refreshAfterWrite(60, TimeUnit.SECONDS)
            // 设置缓存的移除通知
            .removalListener(notification -> {
                System.out.println("key is:" + notification.getKey() + ", value is:" + notification.getValue()
                                   + " 被移除! 原因:" + notification.getCause());
            })
            // build方法中可以指定CacheLoader，在缓存键不存在时通过CacheLoader的实现自动加载键对应的缓存值
            .build(new DemoCacheLoader());
        // 添加元素
        cache.put("a", "1");
        cache.put("b", "2");
        cache.put("c", "3");
        // 获取元素
        System.out.println(cache.get("a"));
        System.out.println(cache.get("d"));
        // 缓存失效
        cache.invalidate("c");
        System.out.println(cache.get("c"));
        // 刷新缓存
        cache.refresh("a");
        System.out.println(cache.get("a"));
        // 缓存命中状态查看
        System.out.println(cache.stats());
    }
    /**
     * 随机缓存加载
     */
    public static class DemoCacheLoader extends CacheLoader<String, String> {
        @Override
        public String load(String key) throws Exception {
            System.out.println(Thread.currentThread().getName() + " 加载" + key + "开始");
            TimeUnit.SECONDS.sleep(1);
            String value = String.valueOf(new Random().nextInt(100));
            System.out.println(Thread.currentThread().getName() + " 加载" + key + "结束");
            return value;
        }
    }
}

CacheBuilder 采用了 builder 设计模式，它的每个方法都返回 CacheBuilder 本身，直到 build 方法被调用。该类中提供了很多的参数设置选项，可以设置 cache 的默认大小，并发数，存活时间，过期策略等等。

其中 LoadingCache 是 Cache 的子接口，相比较于 Cache，当从 LoadingCache 中读取一个指定 key 的记录时，如果该记录不存在可以自动执行加载数据到缓存的操作。当通过 CacheBuilder 构建 Guava Cache 时，如果返回的是 LoadingCache 类型，则在调用 CacheBuilder 的 build 方法时，必须传递一个 CacheLoader 的实现类，用来指定缓存加载的逻辑。当然如果不想指定缓存重建策略，则可以使用无参的 build() 方法，它将返回 Cache 类型的构建对象。

配置解析

1. initialCapacity

用来设置内部哈希表的最小总大小。例如，如果初始容量为 60，并发级别为 8，则会创建八个分段，每个分段有一个大小为 8 的哈希表。如果在构建时提供足够大的话可以避免后续进行昂贵的调整大小操作的需要，但将此值设置为不必要的高会浪费内存。

CacheBuilder.newBuilder()
        .initialCapacity(60)
        .build();

2. concurrencyLevel

�并发级别，允许指定数量的并发更新而不会产生锁争用。如果并发级别为 8，内部会创建 8 个哈希表分段，每个分段由自己的写锁进行控制。这种设计思想类似 JDK 8 之前的 ConcurrentHashMap 的分段锁实现。即使将并发级别设置为 1，一次仅允许一个线程修改缓存，但由于读取操作和缓存加载计算可以并发进行，因此与完全同步相比，仍会产生更高的并发性。

CacheBuilder.newBuilder()
        // 设置并发级别为cpu核心数
        .concurrencyLevel(Runtime.getRuntime().availableProcessors()) 
        .build();

3. 缓存容量

Guava Cache 可以在构建缓存对象时指定缓存所能够存储的最大记录数量。当 Cache 中的记录数量达到最大值后如果再调用 put 方法向其中添加对象，Guava 会先从当前缓存的对象记录中选择一条删除掉，腾出空间后再将新的对象存储到 Cache 中。缓存删除策略有如下两种：

基于容量的清除：当通过 CacheBuilder.maximumSize(long) 方法设置 Cache 的最大容量数时，当缓存数量达到或接近最大值时，Cache 将清除掉那些最近最少（FIFO）使用的缓存

CacheBuilder.newBuilder()
        // 设置缓存最大容量
        .maximumSize(1000) 
        .build();

基于权重的清除：当使用 CacheBuilder.weigher(Weigher) 指定一个权重函数，并且用CacheBuilder.maximumWeight(long) 指定最大总重。比如每一项缓存所占据的内存空间大小都不一样，可以看作它们有不同的权重，当超过最大总重后触发基于权重的清除策略。

CacheBuilder.newBuilder()
    .weigher(new Weigher<String, String>() {
        @Override
        public int weigh(String key, String value) {
            return key.length();
        }
    })
    .maximumWeight(10)
    .build();

4. 缓存定期清除策略

expireAfterWrite：当缓存项被创建或更新其值后经过固定持续时间，自动从缓存中删除该项。但在实现上不是实时的。

expireAfterAccess：缓存项被创建、更新其值或者被访问后经过固定持续时间，自动从缓存中删除该项。读写操作包括 get 和 put 方法，但不包括 containsKey，也不是包括对集合视图的操作。因此，像遍历这种操作不会重置访问时间。

CacheBuilder.newBuilder()
        // 设置写缓存后60秒钟过期
        .expireAfterWrite(60, TimeUnit.SECONDS)
        // 设置读写缓存后60秒钟过期，实际很少用到，一般只使用expireAfterWrite
        .expireAfterAccess(60, TimeUnit.SECONDS)
        .build();

5. refreshAfterWrite

当缓存项被创建或更新其值后经过固定持续时间，进行自动刷新。注意：刷新动作默认实现是同步的。

CacheBuilder.newBuilder()
        // 设置写缓存后60秒钟刷新对应键值对
        .refreshAfterWrite(60, TimeUnit.SECONDS)
        .build();

refreshAfterWrite 通过定时刷新可以让缓存项保持可用，但请注意：缓存项只有在被检索时才会真正刷新。因此，如果同时声明了expireAfterWrite 和 refreshAfterWrite，缓存并不会因为刷新盲目地定时重置，如果缓存项没有被检索，那刷新就不会真的发生，缓存项在过期时间后也变得可以回收。

测试代码示例：

public static void main(String[] args) {
    LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        // 设置1s刷新
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .removalListener(notification -> {
            System.out.println("key is:" + notification.getKey() + ", value is:" + notification.getValue()
                               + " 被移除! 原因:" + notification.getCause());
        })
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                System.out.println(Thread.currentThread().getName() + " 加载" + key + "开始");
                String value = String.valueOf(new Random().nextInt(100));
                System.out.println(Thread.currentThread().getName() + " 加载" + key + "结束");
                return value;
            }
        });
    // 添加元素
    cache.put("a", "1");
    // 等待5s后获取元素
    new Thread(() -> {
        try {
            Thread.sleep(1000 * 5);
            System.out.println(cache.get("a"));
        } catch (Exception e) {
            //
        }
    }).start();
}

运行代码可以发现，在 1 秒后 cache 并没有刷新，而是等到获取元素时才开始刷新。

刷新操作默认是同步的，其内部调用的是 CacheLoader 的 reload方法。如果不想在刷新时影响索引操作，可以在 CacheLoader 的 reload 方法中将加载逻辑实现为异步，这样检索不会被刷新操作所拖慢了。

@Override
public ListenableFuture<Object> reload(String key, Object oldValue) throws Exception {
    ListenableFutureTask<Object> task = ListenableFutureTask.create(() -> load(key));
    Executors.newCachedThreadPool().execute(task);
    // 外部会通过 task.isDone() 方法来判断任务是否完成
    return task;
}

6. removalListener

当缓存项被删除或被更新时触发的监听器。默认情况下，监听器方法是在移除缓存时同步调用的，因为缓存的维护和请求响应通常是同时进行的。如果想要异步调用监听器方法，可以用 RemovalListeners 提供的 asynchronous(RemovalListener, Executor) 方法把监听器装饰为异步操作。

CacheBuilder.newBuilder()
        .removalListener(RemovalListeners.asynchronous(notification -> {
            System.out.println("key is:" + notification.getKey() + ", value is:" + notification.getValue()
                               + " 被移除! 原因:" + notification.getCause());
        }, Executors.newSingleThreadExecutor()))
        .build();

这里提一下 Guava Cache 的自动回收，实际上并不是缓存项过期了以后就马上清理掉，而是在读或写的时候做少量的维护工作，这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程定时检测，但这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样 CacheBuilder 就不可用了。

相反，我们把选择权交到你手里。如果你的缓存是高吞吐的，那就无需担心缓存的维护和清理等工作。如果你的缓存只会偶尔有写操作，而你又不想清理工作阻碍了读操作，那么可以创建自己的维护线程，以固定的时间间隔调用 Cache.cleanUp()。ScheduledExecutorService 可以帮助你很好地实现这样的定时调度。

7. recordStats

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

CacheBuilder.newBuilder()
        .recordStats()
        .build();

Cache 的 stats 方法返回一个 CacheStats 对象，提供了如下方法：

// 缓存查找总次数，其值为hitCount + missCount
public long requestCount()
// 缓存命中次数    
public long hitCount()   
// 缓存命中率
public double hitRate()   
// 缓存未命中次数    
public long missCount()
// 缓存未命中率
public double missRate()    
// 缓存加载次数、成功次数、失败次数、失败率、总耗时、平均时间
public long loadCount()
public long loadSuccessCount()
public long loadExceptionCount()    
public double loadExceptionRate()
public long totalLoadTime()    
public double averageLoadPenalty()    
// 缓存被回收的次数，不包括显式清除
public long evictionCount()

常用方法

/**
 * 返回与此缓存中的key关联的值，如有必要会先加载该值。
 * 如果其他线程同时调用get或getUnchecked方法，只会有一个线程加载值
 */
V get(K key) throws ExecutionException;
V getUnchecked(K key);
/**
 * 显式清除缓存项。包括：单个清除、批量清除、全部清除
 */
void invalidate(@CompatibleWith("K") Object key);
void invalidateAll(Iterable<? extends Object> keys);
void invalidateAll();
/**
 * 显式执行缓存所需的任何挂起的维护操作，比如清除过期缓存
 */
void cleanUp();
/**
 * 显式刷新缓存键，内部调用CacheLoader的reload方法
 */
void refresh(K key);

参考链接：https://github.com/google/guava/wiki/CachesExplained#refresh

Java

Guava Cache 缓存框架