地表最帅缓存Caffeine

2023-09-05 00:16 由敬YES 发表于 #后端开发

简介

缓存是程序员们绕不开的话题，像是常用的本地缓存Guava,分布式缓存Redis等，是提供高性能服务的基础。今天敬姐带大家一起认识一个更高效的本地缓存——Caffeine。

Caffeine Cache使用了基于内存的存储策略，并且支持高并发、低延迟，同时还提供了缓存过期、定时刷新、缓存大小控制等功能。Caffeine是一个Java高性能的本地缓存库。据其官方说明，因使用 Window TinyLfu 回收策略，其缓存命中率已经接近最优值。此处应有掌声👏🏻

它是Guava Cache的升级版本, 但是比Guava Cache更快，更稳定。Caffeine Cache最适合做数据量不大，但是读写频繁的应用场景。结合Redis等可以实现应用中的多级缓存策略。
!

还是老套路，先写代码示例，对Caffeine的帅有个肤浅的认识，后面再去研究他的内在机制

Caffeine缓存类型

新建项目，添加caffeine的maven引用

<!-- https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.7</version>
</dependency>

Caffeine四种缓存类型：Cache, LoadingCache, AsyncCache, AsyncLoadingCache

1. Cache

在获取缓存值时，如果想要在缓存值不存在时，原子地将值写入缓存，则可以调用get(key, k -> value)方法，该方法将避免写入竞争。
在多线程情况下，当使用get(key, k -> value)时，如果有另一个线程同时调用本方法进行竞争，则后一线程会被阻塞，直到前一线程更新缓存完成；而若另一线程调用getIfPresent()方法，则会立即返回null，不会被阻塞。

public class CacheDemo {
    static Cache<Integer, Article> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

    public static void main(String[] args) {
        //get
        System.out.println(cache.get(1, x -> new Article(x)));//Article{id=1, title='title 1'}

        //getIfPresent
        System.out.println(cache.getIfPresent(2));//null

        //put 设置缓存
        cache.put(2, new Article(2));
        System.out.println(cache.getIfPresent(2));//Article{id=2, title='title 2'}

        //invalidate 移除缓存
        cache.invalidate(2);
        System.out.println(cache.getIfPresent(2));//null
    }
}

2.LoadingCache

LoadingCache是一种自动加载的缓存。使用时需要指定CacheLoader，并实现其中的load()方法供缓存缺失时自动加载。
get()方法用来读取缓存，和上面的Cache方式不同之处在于，当缓存不存在或者已经过期时，会自动调用CacheLoader.load()方法加载最新值。加载过程是一种同步操作，将返回值插入缓存并且返回。

/**
 * LoadingCache示例，自动加载的缓存
 *
 * @author chenjing
 */
public class LoadingCacheDemo {
    private static LoadingCache<Integer, Article> cache = Caffeine.newBuilder()
            .build(new CacheLoader<>() {
                @Override
                public @Nullable Article load(Integer id) {
                    return new Article(id);
                }
            });

    public static void main(String[] args) {
        System.out.println(cache.get(1));//Article{id=1, title='title 1'}

        //getIfPresent
        System.out.println(cache.getIfPresent(2));//null


        System.out.println(cache.getAll(List.of(10,20)));//{10=Article{id=10, title='title 10'}, 20=Article{id=20, title='title 20'}}
    }
}

3.AsyncCache

和Cache类似，但是异步执行操作，并返回保存实际值的CompletableFuture，适用于需要进行并发执行提高吞吐量的场景。

/**
 * Caffeine 异步缓存
 *
 * @author chenjing
 */
public class AsyncCacheDemo {
    static AsyncCache<Integer, Article> cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .buildAsync();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //get 返回的是CompletableFuture
        CompletableFuture<Article> future = cache.get(1, x -> new Article(x));
        System.out.println(future.get());//Article{id=1, title='title 1'}
    }
}

4.AsyncLoadingCache

异步加载缓存

/**
 * Caffeine AsyncLoadingCache 异步自动加载缓存
 * @author chenjing 
 */
public class AsyncLoadingCacheDemo {
    private static AsyncLoadingCache<Integer, Article> asyncLoadingCache =
            Caffeine.newBuilder()
                    .maximumSize(1000)
                    .expireAfterWrite(10, TimeUnit.MINUTES)
                    .buildAsync(
                            (key, executor) -> CompletableFuture.supplyAsync(() -> new Article(key), executor)
                    );

    public static void main(String[] args) {

        CompletableFuture<Article> userCompletableFuture = asyncLoadingCache.get(66);
        System.out.println(userCompletableFuture.join());//Article{id=66, title='title 66'}
    }
}

缓存过期

基于缓存大小
通过 maximumSize() 指定缓存大小。

/**
 * 测试Caffeine基于空间的驱逐策略
 *
 * @author chenjing
 */
public class MaxSizeExpire {
    public static void main(String[] args) {
        System.out.println("测试基于容量过期的缓存");
        Integer size = 10;
        Cache<Integer, Article> cache = Caffeine.newBuilder()
                .maximumSize(size)
                .recordStats()
                .build();
        cache.put(1, new Article(1));
        System.out.println("放入一条数据，获取看看");
        System.out.println(cache.getIfPresent(1));//Article{id=1, title='title 1'}

        System.out.println("放入" + size + "条数据");
        for (int i = 2; i <= size + 5; i++) {
            cache.put(i, new Article(i));
        }

        System.out.println("再打印第一条数据看看");
        System.out.println(cache.getIfPresent(1));//Article{id=1, title='title 1'}

        //打印一下缓存状态
        System.out.println(cache.stats());//CacheStats{hitCount=2, missCount=0, loadSuccessCount=0, loadFailureCount=0, totalLoadTime=0, evictionCount=5, evictionWeight=5}
    }
}

基于缓存写入时间
一般最近一段时间缓存的数据才是有效的，缓存很久之前的业务数据是没有意义的。常见的一种场景就是，缓存写入之后N分钟之后自动失效。

/**
 * Caffeine expireAfterWrite
 * @author chenjing
 */
public class ExpireAfterWriteDemo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("测试基于时间过期的缓存");
        Integer seconds = 5;
        Integer size = 5;
        Cache<Integer, Article> cache = Caffeine.newBuilder()
                //基于时间过期
                .expireAfterWrite(seconds, TimeUnit.SECONDS)
                //监控缓存移除
                .removalListener((Integer key, Article value, RemovalCause cause) ->
                        System.out.printf("移除key %s，原因是 %s %n", key, cause))
                .build();

        System.out.println("放入" + size + "条数据");
        for (int i = 1; i <= size; i++) {
            cache.put(i, new Article(i));
            System.out.println(cache.getIfPresent(i));
        }

        System.out.println("sleep 10 seconds");
        Thread.sleep(10000);

        for (int i = 1; i <= size; i++) {
            cache.put(i, new Article(i));
            System.out.println(cache.getIfPresent(i));
        }
    }
}

执行结果：

测试基于时间过期的缓存
放入5条数据
Article{id=1, title='title 1'}
Article{id=2, title='title 2'}
Article{id=3, title='title 3'}
Article{id=4, title='title 4'}
Article{id=5, title='title 5'}
sleep 10 seconds
移除key 1，原因是 EXPIRED
Article{id=1, title='title 1'}
Article{id=2, title='title 2'}
移除key 2，原因是 EXPIRED
移除key 3，原因是 EXPIRED
Article{id=3, title='title 3'}
移除key 4，原因是 EXPIRED
移除key 5，原因是 EXPIRED
Article{id=4, title='title 4'}
Article{id=5, title='title 5'}

缓存刷新

refreshAfterWrite()和expireAfterWrite()不同，在刷新的时候如果查询缓存元素，其旧值将仍被返回，直到该元素的刷新完毕后结束后才会返回刷新后的新值。这里的刷新操作默认也是由线程池ForkJoinPool.commonPool()异步执行的，我们也可以通过Caffeine.executor()重写来指定自定义的线程池。

public class RefreshAfterWriteDemo {
    public static void main(String[] args) throws InterruptedException {
        LoadingCache<Integer, Article> cache = Caffeine.newBuilder()
                .refreshAfterWrite(2, TimeUnit.SECONDS)
                .build(new CacheLoader<Integer, Article>() {
                    @Override
                    public @Nullable Article load(Integer integer) {
                        return new Article(integer);
                    }

                    @Override
                    public @Nullable Article reload(Integer key, Article oldValue) {
                        return new Article(key + 100);
                    }
                });

        cache.put(1, new Article(1));
        for (int i = 0; i < 3; i++) {
            System.out.println(cache.get(1));
            Thread.sleep(3000);
        }
    }
}

缓存监控

创建Caffeine时设置removalListener，可以监听缓存地清除或更新监听。

 Cache<Integer, Article> cache = Caffeine.newBuilder()
                //基于时间过期
                .expireAfterWrite(seconds, TimeUnit.SECONDS)
                //监控缓存移除
                .removalListener((Integer key, Article value, RemovalCause cause) ->
                        System.out.printf("移除key %s，原因是 %s %n", key, cause))
                .build();

当缓存中的数据发送更新，或者被清除时，就会触发监听器，在监听器里可以自定义一些处理手段，比如打印出哪个数据被清除，原因是什么。这个触发和监听的过程是异步的，就是有可能数据都被删除一小会儿了，监听器才监听到。

简介