缓存 - Caffeine 不完全指北-阿里云开发者社区

官网

https://github.com/ben-manes/caffeine

wiki:

https://github.com/ben-manes/caffeine/wiki

概述

Caffeine是一个用于Java应用程序的高性能缓存框架。它提供了一个强大且易于使用的缓存库，可以在应用程序中使用，以提高数据访问的速度和效率。

下面是一些Caffeine缓存框架的主要特点：

高性能：Caffeine的设计目标之一是提供卓越的性能。它通过使用高效的数据结构和优化的算法来实现快速的缓存访问。与其他一些常见的缓存框架相比，Caffeine在缓存访问的速度和响应时间上表现出色。
内存管理：Caffeine提供了灵活的内存管理选项。它支持基于大小、基于数量和基于权重的缓存大小限制。你可以根据应用程序的需求来选择合适的缓存大小策略，并且可以通过配置参数进行进一步的调整。
强大的功能：Caffeine提供了许多强大的功能来满足各种需求。它支持异步加载和刷新缓存项，可以设置过期时间和定时刷新策略，支持缓存项的自动删除和手动失效等。此外，Caffeine还提供了统计信息和监听器机制，可以方便地监控和管理缓存的状态和变化。
线程安全：Caffeine是线程安全的，可以在多线程环境中安全地使用。它使用了细粒度的锁定机制来保护共享资源，确保并发访问的正确性和一致性。
易于集成：Caffeine是一个独立的Java库，可以很容易地与现有的应用程序集成。它与标准的Java并发库和其他第三方库兼容，并且可以与各种框架和技术（如Spring、Hibernate等）无缝集成。

Caffeine 是一个高性能的 Java 缓存框架，旨在提供快速、高效的内存缓存解决方案。它是由 Google 开发的，是 Guava 缓存的升级版。

Caffeine 的设计目标是提供高吞吐量、低延迟的缓存访问，并支持各种缓存策略和功能。以下是一些 Caffeine 框架的关键特点：

高性能：Caffeine 的设计优化了缓存的内存访问模式，使用了各种技术来减少缓存访问的开销，从而提高了性能。它使用了类似于 Java ConcurrentHashMap 的数据结构，支持并发访问，并提供了可配置的并发级别。
内存管理：Caffeine 提供了灵活的内存管理选项，可以通过设置缓存的最大大小、最大条目数或最大权重来控制缓存的大小。它还支持基于容量、时间或引用等策略来自动清理过期的缓存条目。
强大的缓存策略：Caffeine 提供了多种缓存策略，包括基于访问时间、写入时间或自定义规则的过期策略。它还支持最近最少使用（LRU）、最近最不常用（LFU）和固定大小等其他策略。
异步加载：Caffeine 支持异步加载缓存条目的功能。当缓存中不存在所需的条目时，它可以自动触发加载过程，并在加载完成后将结果放入缓存。
统计和监控：Caffeine 提供了丰富的统计和监控功能，可以跟踪缓存的命中率、加载时间、缓存大小等指标。这些信息对于调优和性能分析非常有用。
扩展性：Caffeine 的设计允许开发人员通过自定义策略、缓存加载器和监听器等扩展框架的功能。

使用 Caffeine 缓存框架非常简单。你可以通过以下步骤来开始使用：

引入 Caffeine 依赖：在你的项目中添加 Caffeine 的依赖项，可以通过 Maven、Gradle 或直接下载 JAR 文件进行引入。

创建缓存实例：使用 Caffeine 的构建器模式创建一个缓存实例，可以设置缓存的参数和策略。

存储和获取数据：使用缓存的 put 方法将数据存储到缓存中，使用 get 方法从缓存中获取数据。如果缓存中不存在所需的数据，可以选择触发异步加载或提供自定义加载逻辑。

调优和配置：根据应用程序的需求，可以调整缓存的参数和策略，以获得最佳的性能和内存管理。

总之，Caffeine 是一个功能强大、高性能的 Java 缓存框架，适用于各种应用场景，尤其是需要快速访问、低延迟和高吞吐量的内存缓存需求。

设计

Code

POM

<dependency>
  <groupId>com.github.ben-manes.caffeine</groupId>
   <artifactId>caffeine</artifactId>
   <!-- Java 8 users can continue to use version 2.x, which will be supported -->
   <version>2.9.3</version>
</dependency>

如果是caffeine 3.x的版本，需要JDK 11 以上。

Population

https://github.com/ben-manes/caffeine/wiki/Population

package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.AsyncLoadingCache;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.Builder;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Slf4j
public class CaffeineBaseExampleWithJava {
    @SneakyThrows
    public static void main(String[] args) {
        //  initFirstWay();
        //  initSecondWay();
        initThirdWay();
        TimeUnit.SECONDS.sleep(10);
    }
    /**
     * Cache手动创建
     * <p>
     * 最普通的一种缓存，无需指定加载方式，需要手动调用put()进行加载。需要注意的是put()方法对于已存在的key将进行覆盖，这点和Map的表现是一致的。
     * 在获取缓存值时，如果想要在缓存值不存在时，原子地将值写入缓存，则可以调用get(key, k -> value)方法，该方法将避免写入竞争。调用invalidate()方法，将手动移除缓存。
     * <p>
     * 在多线程情况下，当使用get(key, k -> value)时，如果有另一个线程同时调用本方法进行竞争，则后一线程会被阻塞，直到前一线程更新缓存完成；
     * 而若另一线程调用getIfPresent()方法，则会立即返回null，不会被阻塞。
     */
    @SneakyThrows
    public static void initFirstWay() {
        Cache<Object, Object> cache = Caffeine.newBuilder()
                //初始数量
                .initialCapacity(10)
                //最大条数
                .maximumSize(10)
                //expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准
                //最后一次写操作后经过指定时间过期
                .expireAfterWrite(3, TimeUnit.SECONDS)
                //最后一次读或写操作后经过指定时间过期
                .expireAfterAccess(3, TimeUnit.SECONDS)
                //监听缓存被移除
                .removalListener((key, val, removalCause) -> {
                    log.info("listener remove : {} ,{} ,{}", key, val, removalCause);
                })
                //记录命中
                .recordStats()
                .build();
        cache.put("name", "小工匠");
        //小工匠
        log.info((String) cache.getIfPresent("name"));
        // 结合初始化的时候设置的过期时间, 模拟程序运行5秒后，再此获取
        TimeUnit.SECONDS.sleep(5);
        log.info("5秒后再次获取:{}", (String) cache.getIfPresent("name"));
        //存储的是默认值
        log.info((String) cache.get("noKey", o -> "默认值"));
    }
    /**
     * Loading Cache自动创建
     * <p>
     * LoadingCache是一种自动加载的缓存。其和普通缓存不同的地方在于，当缓存不存在/缓存已过期时，若调用get()方法，则会自动调用CacheLoader.load()方法加载最新值。
     * 调用getAll()方法将遍历所有的key调用get()，除非实现了CacheLoader.loadAll()方法。
     * <p>
     * 使用LoadingCache时，需要指定CacheLoader，并实现其中的load()方法供缓存缺失时自动加载。
     * <p>
     * 在多线程情况下，当两个线程同时调用get()，则后一线程将被阻塞，直至前一线程更新缓存完成。
     */
    @SneakyThrows
    public static void initSecondWay() {
        Map<Integer, Artisan> map = getArtisanMap();
        log.info("size:{}", map.size());
        LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
                //创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache
                .refreshAfterWrite(10, TimeUnit.SECONDS)
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .expireAfterAccess(10, TimeUnit.SECONDS)
                .maximumSize(10)
                //根据key查询数据库里面的值，这里是个lambda表达式
                // TODO  根据其概况初始化 ,比如   build(userId -> getUserFromDatabase(userId));
                //   private User getUserFromDatabase(String userId) {
                //    // 这里会从数据库查询用户信息
                //    // ...
                //    return user;
                //  }
                .build(key -> map.get(Integer.parseInt(key)).toString());
        // 当执行get的时候，会触发 build 中的 lambda表达式
        log.info(loadingCache.get("1"));
        log.info(loadingCache.get("2"));
        log.info(loadingCache.get("3"));
        log.info(loadingCache.get("4"));
        log.info(loadingCache.get("4", o -> "默认值"));
        // 获取一个不存在的值
        log.info(loadingCache.get("noKey", o -> "默认值"));
    }
    /**
     * AsyncCache是Cache的一个变体，其响应结果均为CompletableFuture，
     * 通过这种方式，AsyncCache对异步编程模式进行了适配。
     * <p>
     * 默认情况下，缓存计算使用ForkJoinPool.commonPool()作为线程池，如果想要指定线程池，则可以覆盖并实现Caffeine.executor(Executor)方法。
     * <p>
     * synchronous()提供了阻塞直到异步缓存生成完毕的能力，它将以Cache进行返回。
     * <p>
     * 在多线程情况下，当两个线程同时调用get(key, k -> value)，则会返回同一个CompletableFuture对象。由于返回结果本身不进行阻塞，可以根据业务设计自行选择阻塞等待或者非阻塞。
     */
    @SneakyThrows
    public static void initThirdWay() {
        Map<Integer, Artisan> map = getArtisanMap();
        log.info("size:{}", map.size());
        AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
                //创建缓存或者最近一次更新缓存后经过指定时间间隔刷新缓存；仅支持LoadingCache
                .refreshAfterWrite(1, TimeUnit.SECONDS)
                .expireAfterWrite(1, TimeUnit.SECONDS)
                .expireAfterAccess(1, TimeUnit.SECONDS)
                .maximumSize(10)
                //根据key查询数据库里面的值
                .buildAsync(key -> {
                    Thread.sleep(1000);
                    return map.get(Integer.parseInt(key)).toString();
                });
        //异步缓存返回的是CompletableFuture
        CompletableFuture<String> future = asyncLoadingCache.get("1");
        future.thenAccept(System.out::println);
    }
    private static Map<Integer, Artisan> getArtisanMap() {
        Map<Integer, Artisan> map = new HashMap<>(16);
        map.put(1, Artisan.builder().id(1).name("artisan1").hobbies(Arrays.asList("Java")).build());
        map.put(2, Artisan.builder().id(2).name("artisan2").hobbies(Arrays.asList("AIGC")).build());
        map.put(3, Artisan.builder().id(3).name("artisan3").hobbies(Arrays.asList("HADOOP")).build());
        map.put(4, Artisan.builder().id(4).name("artisan4").hobbies(Arrays.asList("GO")).build());
        return map;
    }
    @Data
    @Builder
    private static class Artisan {
        private Integer id;
        private String name;
        private List<String> hobbies;
    }
}

expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准

Eviction Policy

https://github.com/ben-manes/caffeine/wiki/Eviction

package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Scheduler;
import com.github.benmanes.caffeine.cache.Weigher;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: 驱逐策略在创建缓存的时候进行指定。常用的有基于容量的驱逐和基于时间的驱逐。
 * <p>
 * 基于容量的驱逐需要指定缓存容量的最大值，当缓存容量达到最大时，Caffeine将使用LRU策略对缓存进行淘汰；基于时间的驱逐策略如字面意思，可以设置在最后访问/写入一个缓存经过指定时间后，自动进行淘汰。
 * <p>
 * 驱逐策略可以组合使用，任意驱逐策略生效后，该缓存条目即被驱逐。
 * <p>
 * LRU 最近最少使用，淘汰最长时间没有被使用的页面。
 * LFU 最不经常使用，淘汰一段时间内使用次数最少的页面
 * FIFO 先进先出
 * Caffeine有4种缓存淘汰设置
 * <p>
 * 大小 （LFU算法进行淘汰）
 * 权重 （大小与权重 只能二选一）
 * 时间
 * 引用
 */
@Slf4j
public class CaffeineEvictionPolicy {
    /**
     * 缓存大小淘汰
     */
    @Test
    public void maximumSizeTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //超过10个后会使用W-TinyLFU算法进行淘汰
                .maximumSize(10)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        // 模拟写入数据
        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
        }
        //缓存淘汰是异步的
        Thread.sleep(1000);
        // 打印还没被淘汰的缓存
        log.info("未淘汰的缓存：{}", cache.asMap());
    }
    /**
     * 权重淘汰
     */
    @Test
    public void maximumWeightTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //限制总权重，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
                .maximumWeight(100)
                .weigher((Weigher<Integer, Integer>) (key, value) -> key)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        //总权重其实是=所有缓存的权重加起来
        int maximumWeight = 0;
        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
            maximumWeight += i;
        }
        log.info("总权重={}", maximumWeight);
        //缓存淘汰是异步的
        Thread.sleep(1000);
        // 打印还没被淘汰的缓存
        log.info("未淘汰的缓存：{}", cache.asMap());
    }
    /**
     * 访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）
     */
    @Test
    public void expireAfterAccessTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterAccess(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        log.info("{}", cache.getIfPresent(1));
        Thread.sleep(5000);
        //null
        log.info("{}", cache.getIfPresent(1));
        Thread.sleep(500);
    }
    /**
     * 写入后到期
     */
    @Test
    public void expireAfterWriteTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        Thread.sleep(3000);
        //null
        log.info("{}", cache.getIfPresent(1));
    }
}

Refresh

https://github.com/ben-manes/caffeine/wiki/Refresh

package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * <p>
 * <p>
 * refreshAfterWrite()表示x秒后自动刷新缓存的策略可以配合淘汰策略使用，
 * <p>
 * 注意的是刷新机制只支持LoadingCache和AsyncLoadingCache
 */
@Slf4j
public class CaffeineRefreshPolicy {
    private static int NUM = 0;
    @Test
    public void refreshAfterWriteTest() throws InterruptedException {
        LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
                .refreshAfterWrite(1, TimeUnit.SECONDS)
                //模拟获取数据，每次获取就自增1
                .build(integer -> ++NUM);
        //获取ID=1的值，由于缓存里还没有，所以会自动放入缓存
        // 返回结果 1
        log.info("get value = {}", cache.get(1));
        // 延迟2秒后，理论上自动刷新缓存后取到的值是2
        // 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
        // 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
        Thread.sleep(2000);
        // 返回结果 1
        log.info("get value = {}", cache.getIfPresent(1));
        //此时才会刷新缓存，而第一次拿到的还是旧值 ，这时候拿到的就是新的值了 2
        // 返回结果2
        log.info("get value = {}", cache.getIfPresent(1));
    }
}

Statistics

https://github.com/ben-manes/caffeine/wiki/Statistics

package com.artisan.caffeinedemo.java;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Slf4j
public class CaffeineStatstic {
    @Test
    public void testStatistic() {
        LoadingCache<String, String> cache = Caffeine.newBuilder()
                //创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache
                .refreshAfterWrite(1, TimeUnit.SECONDS)
                .expireAfterWrite(1, TimeUnit.SECONDS)
                .expireAfterAccess(1, TimeUnit.SECONDS)
                .maximumSize(10)
                //开启记录缓存命中率等信息
                .recordStats()
                //根据key查询数据库里面的值
                .build(key -> {
                    Thread.sleep(1000);
                    return new Date().toString();
                });
        cache.put("1", "shawn");
        cache.get("1");
        /*
         * hitCount :命中的次数
         * missCount:未命中次数
         * requestCount:请求次数
         * hitRate:命中率
         * missRate:丢失率
         * loadSuccessCount:成功加载新值的次数
         * loadExceptionCount:失败加载新值的次数
         * totalLoadCount:总条数
         * loadExceptionRate:失败加载新值的比率
         * totalLoadTime:全部加载时间
         * evictionCount:丢失的条数
         */
        log.info("统计信息如下：\n {}", cache.stats());
    }
}

缓存 - Caffeine 不完全指北

官网

概述

设计

Code

POM

Population

Eviction Policy

Refresh

Statistics

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

缓存 - Caffeine 不完全指北

官网

概述

设计

Code

POM

Population

Eviction Policy

Refresh

Statistics

热门文章

最新文章

相关电子书