在 Java 领域，Google Guava 库中的 Cache 模块曾经是本地缓存的事实标准，被广泛应用。然而，随着时间的推移，特别是在对性能要求更高的场景下，另一个优秀的本地缓存库 Caffeine 崭露头角，并被证明在性能上优于 Guava Cache，甚至在 Spring 5 及 Spring Boot 2 以后成为了默认推荐的缓存实现。

理解本地缓存的原理，掌握 Guava Cache 和 Caffeine 这两个常用库的使用方式，并能够清晰地对比它们的优缺点、选择适用场景，是进行应用性能优化和应对面试官考察的关键。

今天，就让我们一起深入 Guava Cache 与 Caffeine 的世界，看看如何选择和使用这两个本地缓存利器！

---

Caffeine Cache 深度解析与 Guava Cache 对比：本地缓存选型指南

引言：缓存是优化性能的利器

在很多应用场景下，数据的访问遵循“二八定律”——少量数据被频繁访问。将这部分热点数据存入缓存，可以直接从内存获取，而无需每次都从慢速存储（如磁盘）或远程服务加载。

• 本地缓存的必要性： 对于单个应用实例内部的重复计算结果、不常变化的数据查询结果等，本地缓存能够提供极低的访问延迟，是提升单体应用或微服务实例性能的首选。

在 Java 中，虽然可以手动实现缓存，但要考虑并发安全、淘汰策略、过期管理等复杂性。Guava Cache 和 Caffeine 提供了成熟、并发安全、功能丰富、高性能的本地缓存实现。

Guava Cache 核心特性回顾 (简要)

Guava Cache 是 Google Guava 库提供的一个本地缓存组件。它使用 Builder 模式构建缓存实例，提供了丰富的缓存功能。

• Builder API (CacheBuilder)： 通过链式调用方法构建缓存实例。

  import com.google.common.cache.Cache;
  import com.google.common.cache.CacheBuilder;
  import java.util.concurrent.TimeUnit;
  
  Cache<String, String> guavaCache = CacheBuilder.newBuilder()
      .maximumSize(1000) // 最大缓存条目数
      .expireAfterWrite(10, TimeUnit.MINUTES) // 写入后10分钟过期
      .recordStats() // 开启统计
      .build();
  

• 常用淘汰策略 (Eviction Policies)：
  • 基于大小：maximumSize(long) (按条目数), maximumWeight(long) + weigher(Weigher) (按权重)。
  • 基于时间：expireAfterWrite(long, TimeUnit) (写入后多久过期), expireAfterAccess(long, TimeUnit) (多久未被访问后过期)。
  • 基于引用：weakKeys(), weakValues(), softValues() (利用 JVM 的弱引用/软引用进行回收)。
• 加载器 (CacheLoader)： CacheLoader<K, V> 接口，用于在缓存中不存在某个 Key 时，定义如何加载对应 Value 的逻辑。

  import com.google.common.cache.CacheLoader;
  import com.google.common.cache.LoadingCache;
  
  LoadingCache<String, String> loadingGuavaCache = CacheBuilder.newBuilder()
      .maximumSize(1000)
      .expireAfterWrite(10, TimeUnit.MINUTES)
      .build(new CacheLoader<String, String>() {
          @Override
          public String load(String key) throws Exception {
              // 当缓存中没有 key 时，执行此方法加载数据
              return key + "_value";
          }
      });
  

• 统计 (Statistics)： 通过 recordStats() 开启，提供命中率、加载次数、淘汰次数等统计信息。
• 移除监听器 (RemovalListener)： 在缓存条目被移除时执行回调。

Caffeine Cache 核心特性详解 (重点)

Caffeine 是一个高性能的 Java 缓存库，旨在成为 Guava Cache 的改进版本和替代品。它实现了与 Guava Cache 类似的 API，但底层实现进行了大量优化。

• Builder API (Caffeine)： API 与 Guava Cache 的 CacheBuilder 非常相似，易于迁移。

  import com.github.benmanes.caffeine.cache.Cache;
  import com.github.benmanes.caffeine.cache.Caffeine;
  import java.util.concurrent.TimeUnit;
  
  Cache<String, String> caffeineCache = Caffeine.newBuilder() // 使用 Caffeine.newBuilder()
      .maximumSize(1000)
      .expireAfterWrite(10, TimeUnit.MINUTES)
      .recordStats()
      .build(); // API 几乎一样
  

• 常用淘汰策略： 支持基于大小、基于时间、基于引用的淘汰策略，与 Guava 类似。
• W-TinyLfu 算法 (优势简述)： 这是 Caffeine 在淘汰算法上的一个重要创新。 它实现了 Window TinyLfu (W-TinyLfu) 淘汰算法，相较于 Guava Cache 使用的 LRU (Least Recently Used) 或其变种，W-TinyLfu 在缓存命中率方面通常表现更好，特别是在存在扫描访问模式（Scan Resistance）的场景下（例如，少量数据被频繁访问，同时大量数据被偶尔访问）。它通过一个小的“窗口”和 LFU (Least Frequently Used) 思想结合，更好地平衡了访问频率和访问时间。
• 加载器 (CacheLoader)： 提供 CacheLoader<K, V> 接口，用于同步加载。
• 异步加载器 (AsyncCacheLoader) 与 异步缓存 (AsyncCache) (重点)： 这是 Caffeine 的一个关键特性改进。
  • AsyncCacheLoader： 用于异步加载数据，load() 方法返回 CompletableFuture。
  • AsyncCache： 一个支持异步存取值的缓存接口。get(key, mappingFunction) 方法返回 CompletableFuture<V>。即使缓存未命中，加载过程也是异步非阻塞的，不会阻塞调用线程。
  • 示例：

    import com.github.benmanes.caffeine.cache.AsyncCache;
    import com.github.benmanes.caffeine.cache.Caffeine;
    import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.TimeUnit;
    
    AsyncCache<String, String> asyncCaffeineCache = Caffeine.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .maximumSize(1000)
        .buildAsync(); // 使用 buildAsync() 构建异步缓存
    
    // 异步获取值
    CompletableFuture<String> futureValue = asyncCaffeineCache.get("myKey", key -> {
        // 如果缓存未命中，异步执行加载逻辑
        System.out.println("Loading data for key: " + key + " asynchronously...");
        return CompletableFuture.supplyAsync(() -> {
            // 模拟一个耗时的异步加载操作
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
            return key + "_async_value";
        });
    });
    
    // 处理异步结果 (非阻塞)
    futureValue.thenAccept(value -> {
        System.out.println("Async value loaded/retrieved: " + value);
    }).exceptionally(e -> {
        System.err.println("Async loading failed: " + e.getMessage());
        return null;
    });
    

  • 作用： 避免缓存穿透导致大量请求阻塞在数据加载上，提高了系统的并发能力和响应性，特别适合在异步或响应式应用中使用。
• 移除监听器 (RemovalListener)： 在缓存条目被移除时执行回调，提供了移除原因 (RemovalCause)。
• 统计 (Statistics)： 通过 recordStats() 开启，提供比 Guava 更丰富的统计信息。
• Spring Cache 集成： Caffeine 可以作为 Spring Caching Abstraction (@Cacheable, @CachePut, @CacheEvict) 的底层实现，提供高性能的本地缓存能力。

Caffeine Cache 架构设计亮点 (简要)

• W-TinyLfu 实现： Caffeine 的 W-TinyLfu 算法通过维护访问频率和访问时间的近似值，并结合分段窗口，能在复杂访问模式下更准确地识别真正的热点数据进行保留，从而提高缓存命中率。
• 异步处理： Caffeine 的异步缓存和加载器设计，利用 CompletableFuture 等异步机制，将缓存的加载和写入操作转移到后台线程，避免阻塞调用线程。

Caffeine Cache 使用方式详细 (重点)

4.1 添加依赖

<dependency>
    <groupId>com.github.benmanes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version> </dependency>

4.2 创建 Cache 实例

使用 Caffeine.newBuilder() 构建同步或异步缓存。

// 同步缓存 - 基本使用
Cache<String, String> cache = Caffeine.newBuilder()
    .maximumSize(100) // 最大条目数
    .expireAfterWrite(5, TimeUnit.MINUTES) // 写入后 5 分钟过期
    .recordStats() // 记录统计信息
    .build();

// 同步缓存 - 使用 CacheLoader
LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
    .maximumSize(100)
    .expireAfterAccess(10, TimeUnit.MINUTES) // 10 分钟未访问过期
    .build(key -> { // 使用 Lambda 定义加载器
        System.out.println("Loading data for key: " + key);
        return key + "_loaded_value";
    });

// 异步缓存 - 无加载器
AsyncCache<String, String> asyncCacheWithoutLoader = Caffeine.newBuilder()
     .maximumSize(100)
     .buildAsync(); // 构建异步缓存

// 异步缓存 - 使用 AsyncCacheLoader
AsyncCache<String, String> asyncCacheWithLoader = Caffeine.newBuilder()
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .maximumSize(100)
    .buildAsync(new com.github.benmanes.caffeine.cache.AsyncCacheLoader<String, String>() {
        @Override
        public CompletableFuture<String> load(String key, java.util.concurrent.Executor executor) {
             // 使用提供的 executor 执行异步加载
             return CompletableFuture.supplyAsync(() -> {
                System.out.println("AsyncCacheLoader loading for key: " + key);
                return key + "_async_loaded_value";
             }, executor);
        }
    });

4.3 存/取值

• put(key, value)： 存入值。
• getIfPresent(key)： 如果缓存中存在该 Key，返回对应的值，否则返回 null。
• get(key, mappingFunction) (同步缓存)： 如果缓存中存在该 Key，返回对应的值。否则，执行 mappingFunction 计算值，将计算结果放入缓存，并返回结果。
• get(key, loader) (同步 LoadingCache)： 如果缓存中存在该 Key，返回对应的值。否则，调用 loader 的 load 方法加载数据，放入缓存，并返回结果。
• get(key, mappingFunction) (异步缓存 AsyncCache)： 如果缓存中存在该 Key，返回 CompletableFuture<V>。如果缓存中不存在或已过期，执行 mappingFunction (返回 CompletableFuture<V>) 进行异步加载，加载过程中不阻塞调用线程，并将 CompletableFuture 放入缓存。
• get(key, asyncLoader) (异步缓存 AsyncCache 使用 AsyncCacheLoader)： 类似，使用构建时指定的 AsyncCacheLoader 进行异步加载。

// 同步缓存存取
cache.put("key1", "value1");
String value1 = cache.getIfPresent("key1"); // 获取值
String value2 = cache.get("key2", k -> "value_from_mapping_" + k); // 缓存中没有 key2 时计算并放入
String value3 = loadingCache.get("key3"); // 缓存中没有 key3 时调用 CacheLoader.load() 加载

// 异步缓存存取
CompletableFuture<String> futureValue1 = asyncCacheWithoutLoader.get("asyncKey1", key -> {
     // 异步计算逻辑，必须返回 CompletableFuture
     return CompletableFuture.supplyAsync(() -> key + "_computed_value");
});
CompletableFuture<String> futureValue2 = asyncCacheWithLoader.get("asyncKey2"); // 使用 AsyncCacheLoader 加载

futureValue1.thenAccept(value -> System.out.println("Got async value1: " + value));
futureValue2.thenAccept(value -> System.out.println("Got async value2: " + value));

4.4 失效 (Invalidate)

• invalidate(key)：失效单个 Key。
• invalidateAll(keys)：失效多个 Key。
• invalidateAll()：失效所有缓存条目。

4.5 统计 (Statistics)

开启 recordStats() 后，可以通过 cache.stats() 获取统计信息。

import com.github.benmanes.caffeine.cache.RemovalCause;
// ... CacheBuilder code with recordStats()

Cache<String, String> cache = Caffeine.newBuilder()
    .maximumSize(10)
    .recordStats()
    .build();

cache.put("a", "1");
cache.put("b", "2");
cache.getIfPresent("a"); // Hit
cache.getIfPresent("c"); // Miss

System.out.println("Stats: " + cache.stats());
// Output will show hits, misses, load counts, eviction counts etc.

4.6 使用 AsyncCache (代码示例)

异步缓存的核心在于 buildAsync() 和返回 CompletableFuture 的 get 方法。

// 参见上面 AsyncCacheWithLoader 的构建和存取示例
// 异步缓存的核心是将加载或计算逻辑包装在 CompletableFuture 中执行，
// 调用方 get() 方法立即返回 CompletableFuture，避免阻塞。

Caffeine Cache 与 Guava Cache 全方位对比分析 (核心！)

Caffeine 被设计为 Guava Cache 的高性能替代品，它们在很多方面相似，但在关键的底层实现和一些特性上有所不同。

特性	Guava Cache	Caffeine Cache	对比说明
性能	良好，但在高并发或复杂访问模式下可能成为瓶颈	卓越，通常性能优于 Guava Cache	Caffeine 通过 W-TinyLfu 和底层优化减少锁竞争和 Cache Miss，吞吐和延迟更优。
淘汰算法	基于 LRU 及其变种 (LRU-W)	W-TinyLfu (Window TinyLfu)	W-TinyLfu 在复杂访问模式下（如扫描访问）命中率通常比 LRU 更好。
异步缓存	无原生异步缓存接口 (需自己包装 CompletableFuture)	原生支持 AsyncCache / AsyncCacheLoader	Caffeine 提供了更便捷的异步加载和存取方式。
加载器	CacheLoader (同步加载)	CacheLoader (同步), AsyncCacheLoader (异步)	Caffeine 增加了异步加载器，支持非阻塞加载。
移除原因	提供 RemovalCause	提供 RemovalCause	相似。
维护状态	维护模式 (Maintenance mode)	积极开发和维护	Guava Cache 不再积极开发新功能，Caffeine 是更活跃的选择。
Spring 集成	支持	支持，Spring Boot 2+ 默认推荐	两者都支持，但新项目和 Spring Boot 环境下 Caffeine 是首选。
API 相似度	极高 (Builder 模式和常用方法相似)	极高	易于从 Guava Cache 迁移到 Caffeine。
底层实现	基于 Segmented Concurrent Map，淘汰算法实现	基于 Concurrent Map，W-TinyLfu 淘汰算法	Caffeine 的底层实现更复杂，但性能优化更好。
概念复杂性	相对简单	稍复杂 (W-TinyLfu, Async Cache)	Caffeine 引入了一些新概念，但整体学习曲线不陡峭。

优缺点总结与选型建议

• Caffeine Cache
  • 优点： 性能卓越，支持异步缓存和异步加载，淘汰算法更优，社区活跃，官方推荐。
  • 缺点： 相较于 Guava Cache，引入时间较短，可能不如 Guava Cache 那么普及（但已是主流）。
• Guava Cache
  • 优点： 成熟稳定，代码久经考验，API 易于理解，社区资料丰富。
  • 缺点： 性能不如 Caffeine，不支持原生异步缓存，淘汰算法相对简单，已进入维护模式。

选型建议：

• 新项目： 强烈推荐使用 Caffeine Cache。 它提供了更好的性能和更现代化的特性，是官方推荐的本地缓存库。
• 遗留项目： 如果项目中已经使用了 Guava Cache 且性能满足要求，可以继续使用。但如果遇到性能瓶颈或希望升级技术栈，迁移到 Caffeine 是一个不错的选择，由于 API 高度相似，迁移成本相对较低。

理解 Caffeine/Guava Cache 对开发者和面试的价值

• 掌握本地缓存原理： 理解缓存的必要性、淘汰策略、加载机制等核心概念。
• 理解高性能实现： 学习 Caffeine 如何通过 W-TinyLfu、无锁、异步等手段实现高性能。
• 具备对比分析能力： 能够清晰地对比不同库的优劣，并根据场景做出技术选型。
• 解决实际性能问题： 学会使用本地缓存优化应用性能。
• 应对面试： 本地缓存是 Java 开发的常用技术，Guava 和 Caffeine 的对比是面试常考点。

Caffeine/Guava Cache 为何是面试热点

• 基础缓存知识： 考察你对缓存概念、淘汰策略、加载机制的理解。
• 常用库实践： 考察你是否了解并使用过业界常用的本地缓存库。
• 性能优化意识： 考察你是否具备性能优化意识，并知道如何使用工具进行优化。
• 技术选型与对比： Caffeine vs Guava 是经典的对比题，考察你分析和评估技术方案的能力。
• 新旧技术演进： Caffeine 作为 Guava Cache 的继任者，体现了技术的发展。

面试问题示例与深度解析

• 什么是本地缓存？为什么需要在应用中使用本地缓存？ (定义，解决 JDBC/远程调用慢，提升性能/响应)
• 请介绍一下 Guava Cache 的核心特性。 (Builder API, 淘汰策略, 加载器, 统计)
• 请介绍一下 Caffeine Cache 的核心特性。它相较于 Guava Cache 有哪些优势？ (核心！ 必考题。Builder API, 淘汰策略, W-TinyLfu 优势，加载器, AsyncCache/AsyncCacheLoader 优势，统计，移除监听器。优势：性能、Async、W-TinyLfu、活跃维护)
• 请解释一下 Guava Cache 和 Caffeine Cache 中常用的淘汰策略。它们有什么区别？ (大小、时间、引用。区别：Guava LRU变种 vs Caffeine W-TinyLfu)
• Caffeine 的 W-TinyLfu 淘汰算法相较于 LRU 有什么优势？ (核心！ 优势：在扫描访问模式下命中率更高，更好地平衡频率和时间)
• 请解释一下 Caffeine 的 AsyncCache 和 AsyncCacheLoader。它们解决了什么问题？适用于什么场景？ (核心！ 解决问题：缓存穿透导致同步加载阻塞调用线程。AsyncCacheLoader 异步加载，AsyncCache 支持异步存取。适用于异步/响应式应用)
• 如何在 Java 中使用 Caffeine Cache？请给出创建 Cache 实例的示例代码。 (回答 Builder API Caffeine.newBuilder()...build())
• 如何在 Spring Boot 中集成 Caffeine Cache？ (引入 spring-boot-starter-cache，通常 Spring Boot 会自动检测并配置 Caffeine)
• 请对比一下 Caffeine Cache 和 Guava Cache。你会在什么情况下选择 Caffeine？什么情况下选择 Guava？ (核心！ 必考题。从性能、淘汰算法、异步支持、维护状态、Spring 集成等方面对比，给出选型建议：新项目/性能要求高选 Caffeine，遗留系统或无性能瓶颈可继续用 Guava，但推荐迁移)
• 本地缓存的数据一致性问题如何考虑？ (本地缓存通常是最终一致的，需要考虑缓存更新、失效、穿透等问题，与分布式缓存的数据一致性方案不同)
• Publisher Confirms 和 Consumer Acknowledgements

总结

本地缓存是优化应用性能的有效手段，Guava Cache 和 Caffeine 是 Java 领域最常用的两个本地缓存库。Guava Cache 经典易用，而 Caffeine Cache 作为其继任者，在性能和异步特性方面进行了显著提升，特别是其 W-TinyLfu 淘汰算法和 AsyncCache/AsyncCacheLoader，使其成为构建高性能应用的更优选择，并已成为现代 Spring Boot 的默认推荐。