解决Caffeine缓存中值意外丢失的问题：深入理解弱引用与缓存生命周期

本文深入探讨了caffeine缓存中值意外丢失的常见问题，特别是由于`weakkeys()`和`weakvalues()`配置以及缓存实例生命周期管理不当所导致的。我们将解析弱引用的工作机制及其潜在陷阱，并提供将缓存声明为`static final`并移除弱引用的最佳实践方案，确保缓存行为的稳定性和可靠性。

理解Caffeine的弱引用机制

Caffeine是一个高性能的Java缓存库，它提供了丰富的配置选项来优化内存使用和性能。其中，weakKeys()和weakValues()是两个与Java垃圾回收机制紧密相关的配置，它们允许缓存使用弱引用来存储键和值。

什么是弱引用？

在Java中，引用分为强引用、软引用、弱引用和虚引用。

• 强引用 (Strong Reference)：最常见的引用类型，如Object obj = new Object();。只要强引用存在，垃圾回收器就永远不会回收被引用的对象。
• 弱引用 (Weak Reference)：通过java.lang.ref.WeakReference类实现。弱引用的特点是，当一个对象只有弱引用指向它时，垃圾回收器在下一次运行时就会回收该对象，无论当前内存是否充足。

weakKeys()和weakValues()的含义与陷阱

• weakKeys(): 配置Caffeine缓存使用弱引用来存储键。这意味着如果缓存外部没有强引用指向某个键对象，那么即使该键在缓存中，垃圾回收器也可能随时回收这个键对象。一旦键被回收，对应的缓存条目（键值对）也会被移除。
• weakValues(): 配置Caffeine缓存使用弱引用来存储值。同理，如果缓存外部没有强引用指向某个值对象，垃圾回收器可能随时回收这个值对象。值被回收后，缓存中的getIfPresent()方法将返回null。

应用场景与潜在问题：

• 优点：在某些特定场景下，如缓存大量只在其他地方有强引用的对象时（例如，缓存JVM内部的字符串常量池中的字符串对象，或者缓存由外部系统管理且其生命周期不确定的对象），弱引用可以帮助减少内存占用，允许JVM在内存压力下或甚至没有内存压力时回收缓存中的条目，从而避免内存溢出。
• 陷阱：对于大多数业务数据缓存场景，我们期望缓存能够可靠地存储数据直到其过期。如果缓存中的键或值对象在缓存外部没有其他强引用，那么即使它们没有达到expireAfterWrite等过期策略，垃圾回收器也可能随时回收它们，导致getIfPresent()方法返回null。这正是原始问题中值意外丢失的根本原因。

// 原始问题中的Caffeine缓存配置示例
private Cache codeCache = Caffeine.newBuilder()
        .expireAfterWrite(24, TimeUnit.HOURS)
        .weakKeys()   // 键使用弱引用
        .weakValues() // 值使用弱引用
        .build();

在这种配置下，当您调用codeCache.put(id, data);时，如果id和data对象在当前方法作用域结束后不再有其他强引用，那么它们就可能被垃圾回收器回收，即使24小时的过期时间还未到。结果就是，随后的codeCache.getIfPresent(id)会返回null。

确保Caffeine缓存实例的生命周期与可见性

除了弱引用问题，Caffeine缓存实例本身的生命周期管理也至关重要。一个缓存实例如果被过早地垃圾回收，其内部存储的所有数据也将随之丢失。

缓存实例的生命周期问题

如果Cache实例被声明为一个普通的对象成员变量（非static），并且它所在的类实例生命周期较短（例如，一个请求作用域的服务类实例），那么当该类实例执行完任务并被垃圾回收时，其内部的Cache实例也会随之被回收，导致缓存中的所有数据丢失。这在分布式系统或高并发场景下尤其容易引发问题，因为不同的请求可能会创建不同的服务实例，每个实例都有自己的缓存，导致数据不一致或丢失。

Question AI

一款基于大模型的免费的AI问答助手、总结器、AI搜索引擎

下载

// 示例：一个非static的缓存可能面临的问题
public class ShortLivedService {
    // 这是一个实例级别的缓存，它的生命周期与ShortLivedService实例绑定
    private Cache instanceCache = Caffeine.newBuilder()
            .expireAfterWrite(1, TimeUnit.MINUTES)
            .build();

    public void processRequest(Long id, SmsData data) {
        instanceCache.put(id, data);
        // ... 执行其他业务逻辑 ...
        // 当ShortLivedService实例执行完请求并被回收后，instanceCache也会随之消失
    }
}

在上述例子中，每次ShortLivedService的实例被创建并处理请求后，其内部的instanceCache也可能随之被销毁，这显然不是我们期望的缓存行为。

static final 的作用

为了确保Caffeine缓存实例具有与应用程序相同的生命周期，并能在整个应用程序中稳定可靠地提供服务，通常建议将其声明为static final：

• static: 将Cache实例声明为静态成员，意味着它属于类本身而不是类的某个特定实例。这样，无论创建多少个该类的实例，都只有一个Cache实例。这对于需要全局共享的缓存是理想的，它确保了所有组件访问的是同一个缓存数据。
• final: 确保Cache引用一旦被初始化后就不能再被修改。这保证了缓存实例的唯一性和不变性，防止在运行时被意外地重新赋值或替换。
• 生命周期：一个static final字段的生命周期与应用程序的生命周期相同（或至少与类加载器生命周期相同）。这意味着static final的缓存实例会在类加载时被初始化，并一直存在直到应用程序关闭。这有效地防止了缓存实例被过早地垃圾回收，从而保证了缓存数据的持久性（在过期策略范围内）。

推荐解决方案与最佳实践

综合上述分析，为了解决Caffeine缓存中值意外丢失的问题，推荐的解决方案是：

1. 将Cache实例声明为static final，确保其具有与应用程序相同的生命周期，并作为应用程序的全局共享资源。
2. 移除weakKeys()和weakValues()配置，除非您明确知道其含义并有特定需求，并能接受其可能带来的数据丢失风险。对于大多数业务数据缓存场景，使用强引用存储键和值是更安全可靠的选择。

以下是修正后的Caffeine缓存配置及使用示例：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;

// 假设SmsData是一个简单的POJO
class SmsData {
    private int sendCount;
    private int checkCount;

    public SmsData() {
        // 默认构造器
    }

    public SmsData(int sendCount, int checkCount) {
        this.sendCount = sendCount;
        this.checkCount = checkCount;
    }

    public int getSendCount() { return sendCount; }
    public void setSendCount(int sendCount) { this.sendCount = sendCount; }
    public int getCheckCount() { return checkCount; }
    public void setCheckCount(int checkCount) { this.checkCount = checkCount; }

    @Override
    public String toString() {
        return "SmsData{" +
               "sendCount=" + sendCount +
               ", checkCount=" + checkCount +
               '}';
    }
}

public class SmsDataCacheManager {

    // 推荐的Caffeine缓存配置：声明为 static final 且不使用弱引用
    private static final Cache CODE_CACHE = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS) // 设置写入后24小时过期
            // .weakKeys()   // 移除此配置，键将使用强引用
            // .weakValues() // 移除此配置，值将使用强引用
            .build();

    /**
     * 存储SmsData到缓存中。
     * @param id 键
     * @param data 值
     */
    public static void storeSmsData(Long id, SmsData data) {
        CODE_CACHE.put(id, data);
        System.out.println("Stored id: " + id + ", data: " + data);
    }

    /**
     * 从缓存中获取SmsData。
     * @param id 键
     * @return 对应的SmsData，如果不存在则为null
     */
    public static SmsData getSmsData(Long id) {
        SmsData data = CODE_CACHE.getIfPresent(id);
        System.out.println("Retrieved id: " + id + ", data: " + data);
        return data;
    }

    public static void main(String[] args) {
        Long testId = 12345L;
        SmsData initialData = new SmsData(1, 0);

        // 存储值
        storeSmsData(testId, initialData);

        // 尝试立即获取值，此时应该能成功获取
        SmsData retrievedData = getSmsData(testId);
        if (retrievedData != null) {
            System.out.println("Successfully retrieved data: " + retrievedData);
        } else {
            System.out.println("Failed to retrieve data immediately after put.");
        }

        // 模拟一段时间后再次获取，只要未过期且没有显式移除，值将保持存在
        // 在没有weakKeys/weakValues的情况下，即使发生GC，值也不会丢失
        try {
            Thread.sleep(100); // 短暂等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        SmsData secondRetrieval = getSmsData(testId);
        if (secondRetrieval != null) {
            System.out.println("Successfully retrieved data after a short delay: " + secondRetrieval);
        } else {
            System.out.println("Failed to retrieve data after a short delay.");
        }

        // 验证过期机制 (可选，需要等待24小时或更短的过期时间)
        // System.out.println("Waiting for cache to expire...");
        // try {
        //     Thread.sleep(TimeUnit.HOURS.toMillis(24) + 1000); // 等待超过24小时
        // } catch (InterruptedException e) {
        //     Thread.currentThread().interrupt();
        // }
        // SmsData expiredData = getSmsData(testId);
        // if (expiredData == null) {
        //     System.out.println("Data successfully expired.");
        // } else {