Java 本地缓存王者：Caffeine 全方位实战指南

在 Java 本地缓存领域，Caffeine 凭借其卓越的性能和丰富的功能，成为当之无愧的首选框架。作为 Guava Cache 的继任者，Caffeine 基于更先进的缓存算法（W-TinyLFU）实现，在命中率、吞吐量和内存效率上都表现出压倒性优势。本文将从基础用法到高级特性，全面解析 Caffeine 的实战技巧。

一、为什么选择 Caffeine？

在正式学习使用方法前，我们先了解 Caffeine 的核心优势，明白为什么它能成为 Java 本地缓存的事实标准：

性能碾压：根据官方基准测试，Caffeine 的吞吐量比 Guava Cache 高出 40% 以上，在高并发场景下表现尤为突出

先进算法：采用 W-TinyLFU 淘汰算法，结合了 LFU（最近最少使用）和 LRU（最近最久未使用）的优点，能智能预测未来可能被访问的数据，大幅提高缓存命中率

丰富特性：支持多种过期策略、异步加载、统计监控等功能，满足复杂业务场景需求

灵活配置：通过流畅的构建器 API，可精确配置缓存的各种行为参数

JDK 兼容：完美支持 Java 8 及以上版本，充分利用 Lambda 表达式简化代码

二、快速入门：Caffeine 基础用法

1. 引入依赖

使用 Maven 的项目在 pom.xml 中添加：

xml 复制代码

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version> <!-- 建议使用最新稳定版 -->
</dependency>

Gradle 项目：

arduino 复制代码

implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'

2. 缓存的创建与基本操作

Caffeine 提供了两种主要的缓存类型：Cache和LoadingCache。其中Cache需要显式加载数据，而LoadingCache则支持自动加载。

（1）基本 Cache 示例

java 复制代码

// 创建一个基本缓存实例
Cache<String, User> userCache = Caffeine.newBuilder()
    .maximumSize(10_000) // 最大缓存条目数
    .expireAfterWrite(5, TimeUnit.MINUTES) // 写入后5分钟过期
    .build();
// 存入数据
userCache.put("user1", new User("1", "张三"));
// 获取数据（不存在则返回null）
User user = userCache.getIfPresent("user1");
// 条件获取：不存在则通过函数加载
User user2 = userCache.get("user2", key -> {
    // 这里编写从数据库或其他数据源加载数据的逻辑
    return userDao.findById(key);
});
// 删除数据
userCache.invalidate("user1");

（2）LoadingCache 示例

当需要缓存不存在时自动加载数据，且加载逻辑统一时，使用LoadingCache更合适：

java 复制代码

// 创建LoadingCache
LoadingCache<String, User> loadingUserCache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterAccess(10, TimeUnit.MINUTES) // 访问后10分钟过期
    .build(new CacheLoader<String, User>() {
        @Override
        public User load(String key) throws Exception {
            // 统一的加载逻辑
            return userDao.findById(key);
        }
    });
// 获取数据（自动触发加载）
try {
    User user = loadingUserCache.get("user1");
} catch (ExecutionException e) {
    // 处理加载过程中可能发生的异常
    throw new RuntimeException("加载用户数据失败", e.getCause());
}
// 无检查异常的获取方式（适用于确定加载不会抛出异常的场景）
User user = loadingUserCache.getUnchecked("user1");

三、核心配置参数详解

Caffeine 的强大之处在于其灵活的配置能力，通过Caffeine.newBuilder()可配置多种参数，精准控制缓存行为：

1. 容量控制

maximumSize(long) ：设置缓存的最大条目数，当达到此数量时，会根据淘汰算法移除旧条目

scss 复制代码

Caffeine.newBuilder().maximumSize(100_000)

maximumWeight(long) + weigher(Weigher) ：按权重控制总容量，适用于不同条目占用内存差异较大的场景

scss 复制代码

Caffeine.newBuilder()
    .maximumWeight(10_000)
    .weigher((key, value) -> calculateWeight(key, value)) // 自定义权重计算

2. 过期策略

Caffeine 支持三种过期策略，可组合使用：

expireAfterWrite：写入后经过指定时间过期，适用于数据会随时间变化的场景

scss 复制代码

.expireAfterWrite(5, TimeUnit.MINUTES) // 写入5分钟后过期

expireAfterAccess：最后一次访问后经过指定时间过期，适用于热点数据随访问变化的场景

scss 复制代码

.expireAfterAccess(30, TimeUnit.SECONDS) // 30秒未访问则过期

expireAfter：自定义过期逻辑，提供更灵活的过期判断

scss 复制代码

.expireAfter((key, value, expirationTime) -> {
    // 自定义过期时间计算，返回过期时间戳（纳秒）
    return expirationTime + calculateExpiration(key, value);
})

3. 刷新策略

刷新与过期不同，刷新是主动加载新数据替换旧数据，而过期是移除旧数据：

refreshAfterWrite：写入后经过指定时间自动刷新，刷新操作由第一个请求触发

scss 复制代码

.refreshAfterWrite(1, TimeUnit.MINUTES) // 写入1分钟后可刷新

配合LoadingCache使用时，刷新会调用CacheLoader的reload方法（可重写自定义），默认实现是异步调用load方法。

4. 移除监听器

当缓存条目被移除时（过期、容量不足被淘汰等），可通过监听器执行后续操作：

scss 复制代码

Caffeine.newBuilder()
    .removalListener((key, value, cause) -> {
        // cause表示移除原因：EXPIRED（过期）、SIZE（容量不足）等
        log.info("缓存移除 - key: {}, cause: {}", key, cause);
        // 可在这里释放与缓存值相关的资源
    })

四、高级特性与实战技巧

1. 异步操作

Caffeine 提供了AsyncCache和AsyncLoadingCache支持异步操作，适合 IO 密集型场景：

typescript 复制代码

// 创建异步加载缓存
AsyncLoadingCache<String, User> asyncUserCache = Caffeine.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .buildAsync(new CacheLoader<String, User>() {
        @Override
        public User load(String key) {
            return userDao.findById(key); // 同步加载方法
        }
    });
// 异步获取，返回CompletableFuture
CompletableFuture<User> future = asyncUserCache.get("user1");
future.thenAccept(user -> {
    // 处理结果
    System.out.println("用户名称：" + user.getName());
});

异步缓存默认使用 ForkJoinPool.commonPool ()，也可通过executor(Executor)指定自定义线程池。

2. 缓存统计

开启统计功能可帮助分析缓存性能，优化缓存策略：

scss 复制代码

Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats() // 开启统计
    .build();
// 使用一段时间后获取统计信息
CacheStats stats = cache.stats();
System.out.println("命中率：" + stats.hitRate());
System.out.println("平均加载时间（纳秒）：" + stats.averageLoadPenalty());
System.out.println("加载失败率：" + stats.loadFailureRate());

关键统计指标：

hitRate() ：缓存命中率，理想情况下应保持在 80% 以上

missRate() ：缓存未命中率

evictionCount() ：被淘汰的条目数

loadSuccessCount()/loadFailureCount() ：加载成功 / 失败次数

3. 弱引用与软引用

为了更好地配合 JVM 垃圾回收，Caffeine 支持弱引用键、弱引用值和软引用值：

weakKeys() ：键使用弱引用，当键没有其他强引用时会被 GC 回收，缓存条目随之移除

weakValues() ：值使用弱引用，当值没有其他强引用时会被 GC 回收

softValues() ：值使用软引用，在内存不足时会被 GC 回收（按 LRU 顺序）

scss 复制代码

// 键使用弱引用，值使用软引用
Cache<String, User> referenceCache = Caffeine.newBuilder()
    .weakKeys()
    .softValues()
    .build();

这些特性适合缓存大对象且希望在内存紧张时自动释放的场景，但会增加 GC 负担，需谨慎使用。

4. 缓存预热

系统启动时主动加载热点数据到缓存，避免运行时缓存未命中导致的性能波动：

ini 复制代码

// 缓存预热实现
LoadingCache<String, Product> productCache = Caffeine.newBuilder()
    .maximumSize(1000)
    .build(key -> loadProduct(key));
// 启动时加载热点商品
List<String> hotProductIds = Arrays.asList("p1001", "p1002", "p1003");
Map<String, Product> hotProducts = productDao.findByIds(hotProductIds);
productCache.putAll(hotProducts);

5. 定时清理过期数据

Caffeine 默认是惰性清理（访问时检查）和周期性维护（后台线程）结合的方式清理过期数据。如果需要更精确的控制，可配置调度器：

ini 复制代码

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
Cache<String, Data> cache = Caffeine.newBuilder()
    .scheduler(Scheduler.forScheduledExecutorService(scheduler)) // 自定义调度器
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build();

五、避坑指南与最佳实践

1. 避免缓存污染

当缓存中混入大量不常访问的数据时，会降低有效数据的命中率，称为缓存污染。解决方案：

合理设置maximumSize，避免缓存过大

对临时数据设置较短的过期时间

结合 W-TinyLFU 算法的特性，信任其淘汰策略

2. 处理缓存穿透

对于查询不存在的数据导致的缓存穿透：

sql 复制代码

// 缓存空值防止穿透
User user = cache.get(key, k -> {
    User result = userDao.findById(k);
    if (result == null) {
        // 缓存空值，设置较短过期时间
        return new NullUser(); // 自定义空对象，避免null值问题
    }
    return result;
});

3. 并发加载控制

默认情况下，当多个线程同时请求同一个未缓存的 key 时，Caffeine 会让所有线程都执行加载操作（"缓存击穿" 风险）。可通过recordStats()监控loadCount是否远大于missCount来判断是否存在此问题。

解决方案是使用loadingCache.get(key)配合同步加载逻辑，或使用AsyncLoadingCache的异步加载。

4. 合理设置过期时间

高频更新数据：expireAfterWrite (1-5 分钟)

低频更新数据：expireAfterWrite (30 分钟 - 1 小时)

几乎不更新的数据：expireAfterAccess (24 小时) + 定期全量刷新

所有过期时间建议添加随机偏移量（如 ±10%），避免缓存雪崩

scss 复制代码

// 带随机偏移的过期时间
.expireAfterWrite(5, TimeUnit.MINUTES)
// 实际使用中可通过自定义expireAfter实现更灵活的随机偏移

5. 结合分布式缓存使用

本地缓存适合存储节点私有的热点数据，而分布式缓存（如 Redis）适合存储全局共享数据。实际项目中通常结合使用：

kotlin 复制代码

// 多级缓存示例
public User getUser(String id) {
    // 1. 先查本地缓存
    User user = localCache.getIfPresent(id);
    if (user != null) {
        return user;
    }
    
    // 2. 再查分布式缓存
    user = redisClient.get("user:" + id);
    if (user != null) {
        localCache.put(id, user); // 同步到本地缓存
        return user;
    }
    
    // 3. 最后查数据库
    user = userDao.findById(id);
    redisClient.set("user:" + id, user, 30, TimeUnit.MINUTES);
    localCache.put(id, user);
    return user;
}

六、总结

Caffeine 作为 Java 本地缓存的佼佼者，凭借其卓越的性能和灵活的配置，成为处理高并发场景的得力助手。本文从基础用法到高级特性，全面介绍了 Caffeine 的实战技巧，包括缓存创建、参数配置、异步操作、统计监控等核心内容。

在实际使用中，需根据业务特点合理配置缓存参数，尤其注意过期策略、容量控制和并发处理。同时，结合分布式缓存构建多级缓存体系，才能在性能与一致性之间取得最佳平衡。

掌握 Caffeine 不仅能显著提升应用性能，更能帮助开发者深入理解缓存设计的核心思想。希望本文能成为你使用 Caffeine 的实用指南，让你的应用在高并发场景下依然保持流畅响应。