Caffeine简介

什么是 Caffeine

Caffeine 是一个高性能的 Java 本地缓存库，由 Ben Manes 开发，基于 Google Guava Cache 设计理念，但在性能上有显著提升。它使用了 W-TinyLFU（Window Tiny Least Frequently Used）淘汰算法，在命中率和性能上都优于传统的 LRU 算法。

为什么选择 Caffeine

性能对比

根据官方基准测试，Caffeine 的性能约为 Guava Cache 的 2 倍：

操作	Caffeine	Guava Cache	ConcurrentHashMap
读取（8线程）	181M ops/s	91M ops/s	285M ops/s
写入（8线程）	50M ops/s	25M ops/s	50M ops/s
读写混合	高	中	高（无淘汰）

命中率对比

W-TinyLFU 算法在各种访问模式下都有更高的命中率：

核心特性

1. W-TinyLFU 淘汰算法

结合了 LRU 和 LFU 的优点：

• Window Cache：新数据进入的窗口区域
• Main Cache：主缓存区域，使用 SLRU 分段
• TinyLFU：使用 Count-Min Sketch 统计访问频率

2. 多种缓存类型

// 手动加载
Cache<String, Object> cache = Caffeine.newBuilder().build();

// 自动加载
LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
    .build(key -> loadFromDB(key));

// 异步加载
AsyncLoadingCache<String, Object> asyncCache = Caffeine.newBuilder()
    .buildAsync(key -> loadFromDB(key));

3. 灵活的过期策略

Caffeine.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)    // 写入后过期
    .expireAfterAccess(5, TimeUnit.MINUTES)    // 访问后过期
    .expireAfter(customExpiry)                  // 自定义过期策略
    .build();

4. 完善的统计功能

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

CacheStats stats = cache.stats();
System.out.println("命中率: " + stats.hitRate());

快速开始

添加依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

基本使用

import com.github.benmanes.caffeine.cache.*;

public class CaffeineDemo {
    public static void main(String[] args) {
        // 创建缓存
        LoadingCache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(1000)                          // 最大缓存条目
            .expireAfterWrite(10, TimeUnit.MINUTES)     // 写入10分钟后过期
            .recordStats()                              // 开启统计
            .build(key -> "value-" + key);              // 加载函数

        // 获取数据（自动加载）
        String value = cache.get("key1");
        System.out.println("Value: " + value);

        // 手动放入
        cache.put("key2", "manual-value");

        // 获取统计信息
        System.out.println("命中率: " + cache.stats().hitRate());
    }
}

Caffeine vs Guava Cache

特性	Caffeine	Guava Cache
性能	更高（约2倍）	高
淘汰算法	W-TinyLFU	LRU
异步支持	原生支持	有限支持
API	兼容 Guava	原版
Spring 集成	默认实现	需要配置
维护状态	活跃	维护中

从 Guava Cache 迁移

Caffeine 的 API 与 Guava Cache 高度兼容，迁移非常简单：

// Guava Cache
LoadingCache<String, Object> guavaCache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(new CacheLoader<String, Object>() {
        @Override
        public Object load(String key) {
            return loadFromDB(key);
        }
    });

// Caffeine（几乎相同的 API）
LoadingCache<String, Object> caffeineCache = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(key -> loadFromDB(key));

适用场景

推荐使用 Caffeine 的场景

1. 高并发读取 - 需要极高的读取性能
2. 热点数据缓存 - 频繁访问的数据
3. Spring Boot 应用 - 默认缓存实现
4. 替换 Guava Cache - 性能升级
5. 需要异步加载 - 非阻塞的缓存加载

不适合的场景

1. 分布式缓存 - 需要使用 Redis 等
2. 大数据量缓存 - 超出 JVM 内存限制
3. 需要持久化 - Caffeine 不支持持久化

小结

Caffeine 是目前 Java 领域最优秀的本地缓存实现，使用 W-TinyLFU 算法在性能和命中率上都有显著优势。它与 Guava Cache API 兼容，迁移成本低，是 Spring Boot 的默认缓存实现。

面试题预览

常见面试题

1. Caffeine 和 Guava Cache 有什么区别？
2. W-TinyLFU 算法的原理是什么？
3. 为什么 Caffeine 的性能比 Guava Cache 高？