guavaCache本地缓存失效方案expireAfterWri

Guava实现本地缓存，为了保证缓存一致性，本地缓存需要被动的失效（即设置失效时间）。Guava Cache有两种缓存刷新机制：

1. expireAfterWrites — 失效后同步加载缓存

在缓存写入后，每隔单位时间移除缓存值。

使用expireAfterWrites后，每次缓存失效LoadingCache都会调用load()方法去重新加载缓存，在加载期间，请求缓存的所有线程都会被阻塞。

@Slf4j
public class TestGuavaCache {

    static LoadingCache<String, String> cache = CacheBuilder.
            newBuilder().
            expireAfterWrite(2, TimeUnit.SECONDS).
            build(new CacheLoader<String, String>() {
                @Override
                public String load(String key) throws Exception {
                    //针对不同的key，同步加载不同的value
                    if ("name".equals(key)) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        return "韩信";
                    }
                    return "";
                }

            });

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        cache.put("name", "李白");
        //第一次获取缓存值：李白
        log.info(cache.getUnchecked("name"));
        Thread.sleep(2000);
        //睡眠2s后，再次获取缓存值，但缓存也失效了，去加载缓存（耗时1s）总共等待的是3s。
        log.info(cache.getUnchecked("name"));
        Thread.sleep(1000);
        //睡眠1s后，缓存未失效，再次获取缓存，直接获取到缓存值。
        log.info(cache.getUnchecked("name"));
    }
}

执行结果：

2020-06-12 13:56:39,113 INFO [203] [main] [] (TestGuavaCache.java:64): 李白
2020-06-12 13:56:42,155 INFO [3245] [main] [] (TestGuavaCache.java:66): 韩信
2020-06-12 13:56:43,157 INFO [4247] [main] [] (TestGuavaCache.java:69): 韩信

2. refreshAfterWrites — 失效后异步刷新缓存

使用refreshAfterWrites后，需要实现CacheLoader的reload方法。需要在方法中创建一个ListenableFutureTask，然后将这个task提交给线程池去异步执行。这样的话，缓存失效后重新加载就变成了异步，加载期间尝试获取取缓存的线程也不会被阻塞。而是获取到加载之前的值。加载完毕之后，各个线程就能取到最新的值。

@Slf4j
public class TestGuavaCache {
    private static ExecutorService executorService = Executors.newFixedThreadPool(5);


    static LoadingCache<String, String> cache = CacheBuilder.
            newBuilder().
            refreshAfterWrite(2, TimeUnit.SECONDS).
            build(new CacheLoader<String, String>() {
                //同步加载缓存
                @Override
                public String load(String key) throws Exception {
                    //针对不同的key，同步加载不同的value
                    if ("name".equals(key)) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        return "韩信";
                    }
                    return "";
                }

                //异步加载缓存
                @Override
                public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
                    //定义任务。
                    ListenableFutureTask<String> futureTask = ListenableFutureTask.create(() -> {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        return "曹操";
                    });
                    //异步执行任务
                    executorService.execute(futureTask);
                    return futureTask;
                }

            });


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        cache.put("name", "李白");
        //第一次获取缓存：李白
        log.info(cache.getUnchecked("name"));
        //睡眠2s后，再次获取，此时缓存失效，异步的加载缓存。但是线程是立即返回“旧结果”。
        Thread.sleep(2000);
        log.info(cache.getUnchecked("name"));
        Thread.sleep(1000);
        log.info(cache.getUnchecked("name"));
    }
}

执行结果：

2020-06-12 14:05:45,625 INFO [233] [main] [] (TestGuavaCache.java:63): 李白
2020-06-12 14:05:47,699 INFO [2307] [main] [] (TestGuavaCache.java:65): 李白
2020-06-12 14:05:48,705 INFO [3313] [main] [] (TestGuavaCache.java:67): 曹操

总结：refreshAfterWrites是异步去刷新缓存的方法，使用过期的旧值快速响应。而expireAfterWrites缓存失效后线程需要同步等待加载结果，可能会造成请求大量堆积的问题。