Guava Cache详解

适用性

　　缓存在很多场景下都是相当有用的。例如，计算或检索一个值的代价很高，并且对同样的输入需要不止一次获取值的时候，就应当考虑使用缓存

　　Guava Cache与ConcurrentMap很相似，但也不完全一样。最基本的区别是ConcurrentMap会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存

　　通常来说，Guava Cache适用于：

• • 你愿意消耗一些内存空间来提升速度。
  • 你预料到某些键会被查询一次以上。
  • 缓存中存放的数据总量不会超出内存容量。（Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。如果这不符合你的需求，请尝试Redis这类工具）

　　如果你的场景符合上述的每一条，Guava Cache就适合你。

　　如果你不需要Cache中的特性，使用ConcurrentHashMap有更好的内存效率——但Cache的大多数特性都很难基于旧有的ConcurrentMap复制，甚至根本不可能做到

代码详解

/**
 * @author LiuHuan
 * @date 2020-06-17 15:52
 * @desc Guava Cache学习
 */
public class GuavaCacheTest {

    public static void main(String[] args) throws ExecutionException {
        GuavaCacheTest test = new GuavaCacheTest();
        Cache<String, String> cache = test.getGuavaCache();
        // 放入/覆盖一个缓存
        cache.put("key", "value");
        // 获取一个缓存，如果该缓存不存在则返回一个null值
        cache.getIfPresent("");
        // 获取缓存，当缓存不存在时，则通Callable进行加载并返回。该操作是原子
        cache.get("key", () -> loadingValue("key"));
        // 回收key为k1的缓存
        cache.invalidate("key");
        // 使用Map的put方法进行覆盖刷新
        cache.asMap().put("key", "value");
        // 使用ConcurrentMap的replace方法进行覆盖刷新
        cache.asMap().replace("key", "value1");
        // 使用Map的putAll方法进行批量覆盖刷新
        Map<String,String> needRefresh = ImmutableMap.of("key1","value1", "key2", "value2");
        cache.asMap().putAll(needRefresh);
        // 批量回收key为key1、key2的缓存
        List<String> needInvalidateKeys = Arrays.asList("key1", "key2");
        cache.invalidateAll(needInvalidateKeys);
        // 回收所有缓存
        cache.invalidateAll();

        // 用来开启Guava Cache的统计功能。统计打开后，Cache.stats()方法会返回CacheStats对象
        CacheStats stats = cache.stats();
        // 缓存命中率
        double hitRate = stats.hitRate();
        // 加载新值的平均时间，单位为纳秒
        double averageLoadPenalty = stats.averageLoadPenalty();
        // 缓存项被回收的总数，不包括显式清除
        long evictionCount = stats.evictionCount();

        LoadingCache<String, String> loadingCache = test.getGuavaLoadingCache();
        // loadingCache 在进行刷新时无需显式的传入value
        loadingCache.refresh("key");
    }

    /**
     * 获取GuavaCache实例
     * @return
     */
    public Cache<String, String> getGuavaCache(){
        // 异步触发监听器
        RemovalListener<Object, Object> removalListener = RemovalListeners.asynchronous(removal -> {
            // 如果被显示移除这里为true
            boolean wasEvicted = removal.wasEvicted();
            // 移除的原因
            RemovalCause cause = removal.getCause();
        }, Executors.newSingleThreadExecutor());
        
        // 通过CacheBuilder构建一个缓存实例
        Cache<String, String> cache = CacheBuilder.newBuilder()
            // 由于Guava的缓存使用了分离锁的机制，扩容的代价非常昂贵，所以合理的初识容量能够减少扩容次数
            .initialCapacity(100)
            // 设置缓存的最大条数
            .maximumSize(100)
            // maximumWeight逻辑上用来表示一种“权重”，这里与maximumSize冲突，设置一个即可
            // 这里我们将key和value所占的字节数，作为weight，当cache中所有的“weight”总和达到maximumWeight时，将会触发“剔除策略”
            .maximumWeight(1024 * 1024)
            .weigher((Weigher<String, String>)(key, value) -> key.getBytes().length + value.getBytes().length)
            // 使用弱引用存储键。当键没有其它（强或软）引用时，该缓存可能会被回收
            .weakKeys()
            // 使用弱引用存储值。当值没有其它（强或软）引用时，该缓存可能会被回收
            .weakValues()
            // 使用软引用存储值。当内存不足并且该值其它强引用引用时，该缓存就会被回收
            // 通过软/弱引用的回收方式，相当于将缓存回收任务交给了GC，使得缓存的命中率变得十分的不稳定，在非必要的情况下，还是推荐基于数量和容量的回收
            .softValues()
            // 设置缓存在写入一分钟后失效
            .expireAfterWrite(1, TimeUnit.MINUTES)
            // 设置缓存最后一次访问10分钟之后失效，与session类似。与expireAfterWrite冲突，设置一个即可
            .expireAfterAccess(Duration.ofMinutes(10))
            // 开启缓存统计
            .recordStats()
            // 设置并发级别为CPU核心数
            .concurrencyLevel(Runtime.getRuntime().availableProcessors())
            // 移除监听器，这里是移除缓存时同步调用，会拖慢正常的请求
            .removalListener(removal -> {
                // 如果被显示移除这里为true
                boolean wasEvicted = removal.wasEvicted();
                // 移除的原因
                RemovalCause cause = removal.getCause();
            })
            // 异步触发监听器
            .removalListener(removalListener)
            .build();
        return cache;
    }

    /**
     * 获取GuavaLoadingCache实例，会有默认的缓存加载策略
     * @return
     */
    public LoadingCache<String, String> getGuavaLoadingCache(){
        // 通过CacheBuilder构建一个缓存实例
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            // 设置缓存在写入10分钟后，通过CacheLoader的load方法进行刷新
            .refreshAfterWrite(Duration.ofMinutes(10))
            .build(new CacheLoader<String, String>() {
                @Override
                public String load(String key) throws Exception {
                    // 缓存加载策略
                    return loadingValue(key);
                }

            });
        return cache;
    }

    /**
     * 缓存加载策略
     * @param key
     * @return
     */
    private static String loadingValue(String key){
        return null;
    };

}

缓存清理　　

　　使用CacheBuilder构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。相反，它会在写操作时顺带做少量的维护工作，如果写操作实在太少的话，偶尔在读操作时做这个操作。这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样CacheBuilder就不可用了。

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