码拉松

高性能缓存Caffeine的基本使用方式

文章目录

介绍
性能比对
使用方式
- 一、Population（缓存类型）
- - 1.Cache
  - 2.Loading
  - 3.Asynchronous (Manual)
  - 4.Asynchronously Loading
- 二、Eviction（驱除策略）
- - 1.Size-based（基于容量）
  - 2.Time-based（基于时间）
  - 3.Reference-based（基于引用）
- 三、Explicit Removals（显示删除）
- - 1.直接删除
  - 2.可监听删除
- 四、Refresh（刷新机制）
- 五、Statistics（统计）
Caffeine在SpringBoot中的使用

介绍

Caffeine是基于JDK1.8版本的高性能本地缓存库，它是Guava的增强版，与ConcurrentLinkedHashMap相似，支持并发，并且可以在O(1)的时间复杂度内查找、写入元素。

性能比对

使用方式

一、Population（缓存类型）

1.Cache

private static void manual() {
    // 构建caffeine的缓存对象，并指定在写入后的10分钟内有效，且最大允许写入的条目数为10000
    Cache<String, String> cache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(10_000)
            .build();
    String key = "hello";
    // 查找某个缓存元素，若找不到则返回null
    String str = cache.getIfPresent(key);
    System.out.println("cache.getIfPresent(key) ---> " + str);
    // 查找某个缓存元素，若找不到则调用函数生成，如无法生成则返回null
    str = cache.get(key, k -> create(key));
    System.out.println("cache.get(key, k -> create(key)) ---> " + str);
    // 添加或者更新一个缓存元素
    cache.put(key, str);
    System.out.println("cache.put(key, str) ---> " + cache.getIfPresent(key));
    // 移除一个缓存元素
    cache.invalidate(key);
    System.out.println("cache.invalidate(key) ---> " + cache.getIfPresent(key));
}


private static String create(Object key) {
    return key + " world";
}

输出结果：

cache.getIfPresent(key) ---> null
cache.get(key, k -> create(key)) ---> hello world
cache.put(key, str) ---> hello world
cache.invalidate(key) ---> null

2.Loading

LoadingCache是附加在CacheLoader之上构建的缓存对象。

可以使用getAll方法执行批量查找，默认情况下，getAll()方法会单独调用CacheLoader.load()方法来加载每个不在缓存中的Key，必要情况下可以重写CacheLoader.loadAll()方法来弥补其缺陷。

public static void loading() {
    LoadingCache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build(key -> create(key)); // 当调用get或者getAll时，若找不到缓存元素，则会统一调用create(key)生成
    String key = "hello";
    String str = cache.get(key);
    System.out.println("cache.get(key) ---> " + str);
    List<String> keys = Lists.newArrayList("a", "b", "c", "d", "e");
    // 批量查找缓存元素，如果缓存不存在则生成缓存元素
    Map<String, String> maps = cache.getAll(keys);
    System.out.println("cache.getAll(keys) ---> " + maps);
}

private static String create(Object key) {
    return key + " world";
}

输出结果

cache.get(key) ---> hello world
cache.getAll(keys) ---> {a=a world, b=b world, c=c world, d=d world, e=e world}

3.Asynchronous (Manual)

AsyncCache就是Cache的异步实现方式，提供了通过Executor生成缓存元素并返回CompletableFuture的能力。
synchronous()提供了在缓存计算完成前的阻塞能力，AsyncCache默认使用ForkJoinPool.commonPool()线程池，你也可以通过重写Caffeine.executor(executor)来实现自己的线程池。

private static void asynchronous() {
    AsyncCache<String, String> cache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(10_000)
            .buildAsync();
    String key = "Hello";
    // 查找某个缓存元素，若找不到则返回null
    CompletableFuture<String> value = cache.getIfPresent(key);
    // 查找某个缓存元素，若不存在则异步调用create方法生成
    value = cache.get(key, k -> create(key));
    // 添加或者更新一个缓存元素
    cache.put(key, value);
    // 移除一个缓存元素
    cache.synchronous().invalidate(key);
}

4.Asynchronously Loading

AsyncLoadingCache就是LoadingCache的异步形式

private static void asynchronouslyLoading() {
    AsyncLoadingCache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            // 异步构建一个同步的调用方法create(key)
            .buildAsync(key -> create(key));
    // 也可以使用下面的方式来异步构建缓存，并返回一个future
    // .buildAsync((key, executor) -> createAsync(key, executor));
    String key = "Hello";
    // 查找某个缓存元素，若找不到则会异步生成。
    CompletableFuture<String> value = cache.get(key);
    List<String> keys = Lists.newArrayList("a", "b", "c", "d", "e");
    // 批量查找某些缓存元素，若找不到则会异步生成。
    CompletableFuture<Map<String, String>> graphs = cache.getAll(keys);
}

二、Eviction（驱除策略）

1.Size-based（基于容量）

private static void sizeBased() {
    // 基于缓存内元素的个数，尝试回收最近或者未经常使用的元素
    LoadingCache<String, String> values = Caffeine.newBuilder()
            .maximumSize(10_000)
            .build(key -> create(key));
    // 也可以基于缓存元素的权重，进行驱除
    LoadingCache<String, String> graphs = Caffeine.newBuilder()
            .maximumWeight(10_000)
            .weigher((String key, String value) -> value.length())
            .build(key -> create(key));
}

2.Time-based（基于时间）

private static void timeBased() {
    // 自上一次写入或者读取缓存开始，在经过指定时间之后过期。
    LoadingCache<String, String> fixedAccess = Caffeine.newBuilder()
            .expireAfterAccess(5, TimeUnit.MINUTES)
            .build(key -> create(key));
    // 自缓存生成后，经过指定时间或者一次替换值之后过期。
    LoadingCache<String, String> fixedWrite = Caffeine.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build(key -> create(key));
    // 自定义缓存过期策略，可以在创建时，写入后、读取时。
    LoadingCache<String, String> varying = Caffeine.newBuilder()
            .expireAfter(new Expiry<String, String>() {
                public long expireAfterCreate(String key, String value, long currentTime) {
                    return currentTime;
                }
                public long expireAfterUpdate(String key, String value,
                                              long currentTime, long currentDuration) {
                    return currentDuration;
                }
                public long expireAfterRead(String key, String value,
                                            long currentTime, long currentDuration) {
                    return currentDuration;
                }
            })
            .build(key -> create(key));
}

3.Reference-based（基于引用）

private static void referenceBased() {
    // 当缓存key和value都不存在强引用关系时，进行驱逐
    LoadingCache<String, String> weak = Caffeine.newBuilder()
            .weakKeys()
            .weakValues()
            .build(key -> create(key));
    // 当发生GC时进行驱逐
    LoadingCache<String, String> soft = Caffeine.newBuilder()
            .softValues()
            .build(key -> create(key));
}

三、Explicit Removals（显示删除）

1.直接删除

// 直接删除
cache.invalidate(key)
// 批量删除
cache.invalidateAll(keys)
// 删除所有
cache.invalidateAll()

2.可监听删除

监听缓存元素被删除或者被驱除事件

private static void removalsListeners() {
    Cache<String, String> cache = Caffeine.newBuilder()
    		// 注意：evictionListener是3.X版本中新特性，2.X版本中没有
            .evictionListener((String key, String value, RemovalCause cause) ->
                    System.out.printf("Key %s was removed (%s)%n", key, cause))
            .removalListener((String key, String value, RemovalCause cause) ->
                    System.out.printf("Key %s was removed (%s)%n", key, cause))
            .build();
    cache.put("Hello", "Caffeine");
    System.out.println(cache.getIfPresent("Hello"));
    cache.invalidate("Hello");
    try {
        // 监听是异步执行的
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

四、Refresh（刷新机制）

refresh只有在LoadingCache或者AsyncLoadingCache时才能使用，与驱逐不同之处，在刷新的时候，如果访问元素仍然可以返回，但返回的是旧值。

static StringBuffer stringBuffer = new StringBuffer(">");
private static void refresh() {
    LoadingCache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .refreshAfterWrite(1, TimeUnit.SECONDS)
            .build(key -> stringBuffer.append(key).toString());
    for (int i = 0; i < 5; i++) {
    	// 这里需要注意，前两次输出都是：“>*”
    	// 理论上第二次输出应是：“>**”，这是因为refreshAfterWrite刷新实际上指的是在x秒、并且是第二次访问之后才开始刷新
        System.out.println(cache.get("*"));
        try {
            Thread.sleep(1200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}