Caffeine缓存深度解析：解决弱引用导致的值丢失与实例管理问题

聖光之護

发布时间：2025-11-09 15:25:01

792人浏览过

来源于php中文网

原创

caffeine缓存深度解析：解决弱引用导致的值丢失与实例管理问题

本教程深入探讨Caffeine缓存中常见的弱引用（`weakKeys`/`weakValues`）导致值丢失的问题，并解析缓存实例生命周期管理的重要性。通过分析弱引用的工作机制和`static final`修饰符的作用，提供了一种确保缓存数据持久性和一致性的解决方案，帮助开发者正确配置和使用Caffeine缓存。

Caffeine是一个高性能的Java内存缓存库，它提供了丰富且灵活的配置选项，包括基于时间、大小的驱逐策略以及对弱引用和软引用的支持。然而，不恰当的配置，特别是对弱引用的误解，可能导致缓存行为不符合预期，例如值在被存入后立即消失。

理解Caffeine缓存中的弱引用陷阱

在Caffeine中，可以通过weakKeys()和weakValues()方法配置缓存，使其键或值被弱引用（Weak Reference）持有。这是一种在Java内存管理中相对高级的概念，其核心机制在于：如果一个对象只被弱引用引用，那么垃圾回收器（Garbage Collector, GC）在下一次运行时会回收这个对象。

考虑以下一个常见的错误配置示例：

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

public class ProblematicCacheExample {

    // 缓存被配置为使用弱键和弱值
    private Cache<Long, SmsData> codeCache = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS)
            .weakKeys() // 弱键
            .weakValues() // 弱值
            .build();

    // 假设SmsData是一个简单的POJO
    static class SmsData {
        private int sendCount;
        private int checkCount;
        // 省略构造器、getter和setter
        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 void storeAndRetrieve(long id, int currentSendCount) {
        SmsData dataToStore = new SmsData();
        dataToStore.setSendCount(++currentSendCount);
        dataToStore.setCheckCount(0);

        codeCache.put(id, dataToStore); // 存入缓存
        System.out.println("尝试存入缓存，key: " + id + ", value: " + dataToStore);

        SmsData retrievedData = codeCache.getIfPresent(id); // 立即尝试获取
        if (retrievedData == null) {
            System.out.println("错误：从缓存获取失败，key: " + id + " 返回 null。");
        } else {
            System.out.println("成功从缓存获取，key: " + id + ", value: " + retrievedData);
        }
    }

    public static void main(String[] args) {
        ProblematicCacheExample example = new ProblematicCacheExample();
        example.storeAndRetrieve(123L, 0);
        // 强制进行垃圾回收，模拟弱引用被回收的场景
        System.gc();
        try {
            Thread.sleep(100); // 稍作等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("GC后再次尝试获取...");
        SmsData dataAfterGC = example.codeCache.getIfPresent(123L);
        System.out.println("GC后获取结果: " + (dataAfterGC == null ? "null" : dataAfterGC));
    }
}

在上述代码中，尽管我们刚刚将SmsData对象放入缓存，但getIfPresent(id)可能会立即返回null。这是因为：

弱引用特性： 当dataToStore对象被放入缓存后，如果storeAndRetrieve方法执行完毕，并且没有其他强引用指向dataToStore对象，那么该对象就只被缓存中的弱引用所持有。
垃圾回收： 此时，垃圾回收器随时可能运行，一旦运行，它就会回收这个只被弱引用持有的dataToStore对象。当值被回收后，Caffeine缓存中对应的条目就会被移除，导致getIfPresent返回null。
不可预测性： 弱引用导致的驱逐是由GC触发的，因此其发生时间是不可预测的，可能在数据刚被放入缓存后就发生，与expireAfterWrite等基于时间的过期策略完全不同。

缓存实例的生命周期管理：static final的重要性

除了弱引用配置，缓存实例本身的生命周期管理也至关重要。在上述示例中，codeCache被声明为一个非static的实例变量。如果ProblematicCacheExample类是某个服务或控制器的一部分，并且其每次请求都会创建一个新的实例，那么每次创建新的ProblematicCacheExample对象时，都会创建一个全新的codeCache实例。

这意味着：

不同的ProblematicCacheExample实例将拥有各自独立的codeCache，它们之间的数据不共享。
在一个实例中放入的数据，无法在另一个实例中获取。
当一个ProblematicCacheExample实例的生命周期结束（例如，请求处理完毕），其内部的codeCache实例也会随之被垃圾回收，导致其中存储的所有数据丢失。

将缓存实例声明为static final是解决这类问题的一种常用且有效的方式：

static关键字： 使得codeCache成为类的静态成员，而不是特定对象的成员。这意味着无论创建多少个ProblematicCacheExample类的实例，它们都将共享同一个codeCache实例。
final关键字： 确保codeCache引用一旦初始化后就不能再改变，进一步保证了其作为单例缓存的稳定性。

结合使用static final通常用于创建应用程序范围内的单例缓存实例，确保其在应用程序整个生命周期中只存在一个，并且数据能够被所有需要的地方访问和共享。

一点PPT

一句话生成专业PPT，AI自动排版配图

下载

解决方案与最佳实践

综合上述分析，解决Caffeine缓存中值丢失问题的关键在于：

谨慎使用弱引用 (weakKeys(), weakValues())：
- 对于大多数常规缓存需求，应避免使用弱引用。 如果你的目标是基于时间（如expireAfterWrite）或大小（如maximumSize）进行显式驱逐，并且希望缓存中的值在未过期前保持可访问，那么强引用是默认且更合适的选择。
- 仅在特定高级场景下考虑使用弱引用。 例如，当你缓存的是对可能被垃圾回收的对象（如大型图片对象或外部资源句柄）的“辅助”信息时，并且你希望当这些主对象被GC时，缓存中的对应条目也自动消失，此时弱引用才可能适用。在这种情况下，缓存不再是数据的“持有者”，而是数据的“观察者”。
确保缓存实例的正确生命周期：
- 对于应用程序级别的共享缓存，应将其声明为static final，以确保其在应用程序整个生命周期中只存在一个，并且数据能够被所有需要的地方访问和共享。
- 在Spring等框架中，可以通过将缓存配置为单例Bean来实现类似的效果，由框架管理其生命周期。

修正后的代码示例

以下是根据最佳实践修正后的Caffeine缓存使用方式：

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

public class CorrectCaffeineCacheExample {

    // 假设SmsData是一个简单的POJO
    static class SmsData {
        private int sendCount;
        private int 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 +
                   '}';
        }
    }

    // 声明为 static final，确保缓存实例的唯一性和持久性
    // 移除 weakKeys() 和 weakValues()，使用默认的强引用
    private static final Cache<Long, SmsData> codeCache = Caffeine.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS) // 根据业务需求设置过期策略
            .maximumSize(10_000) // 可选：设置最大缓存条目数，防止内存溢出
            .build();

    public void processSmsData(long id, int initialSendCount) {
        int currentSendCount = initialSendCount;

        // 尝试从缓存获取数据
        SmsData data = codeCache.getIfPresent(id);
        if (data == null) {
            // 缓存中不存在，创建新数据
            data = new SmsData();
            data.setSendCount(++currentSendCount);
            data.setCheckCount(0);
            System.out.println("缓存中无数据，创建新数据并存入。key: " + id + ", value: " + data);
        } else {
            // 缓存中存在，更新数据
            data.setSendCount(++currentSendCount);
            System.out.println("从缓存获取数据并更新。key: " + id + ", value: " + data);
        }

        // 确保数据存回缓存（即使是更新也需要put，因为SmsData是可变对象）
        codeCache.put(id, data);
        System.out.println("数据已存入/更新缓存。");

        // 再次尝试获取，验证数据是否持久
        SmsData retrievedData = codeCache.getIfPresent(id);
        if (retrievedData != null) {
            System.out.println("验证：成功从缓存获取，key: " + id + ", value: " + retrievedData);
        } else {
            System.out.println("验证：从缓存获取失败，key: " + id + " 返回 null。这不应该发生！");
        }
    }

    public static void main(String[] args) {
        CorrectCaffeineCacheExample example = new CorrectCaffeineCacheExample();
        long smsId = 456L;

        // 第一次调用，数据会存入缓存
        example.processSmsData(smsId, 0);

        // 模拟后续操作，数据应能从缓存中获取并更新
        System.out.println("\n--- 模拟后续操作 ---");
        example.processSmsData(smsId, example.codeCache.getIfPresent(smsId).getSendCount()); // 传入当前sendCount

        // 模拟另一个实例（但由于是static final，实际上是同一个缓存）
        System.out.println("\n--- 模拟另一个实例或线程访问 ---");
        CorrectCaffeineCacheExample anotherExample = new CorrectCaffeineCacheExample();
        anotherExample.processSmsData(smsId, anotherExample.codeCache.getIfPresent(smsId).getSendCount());
    }
}

运行上述修正后的代码，你会发现数据能够被正确地存入和获取，并且在不同的调用或“实例”之间保持一致性。

总结

Caffeine是一个功能强大的缓存库，但其配置细节对缓存行为有着决定性的影响。在使用Caffeine时，开发者应：

避免滥用弱引用： 除非有明确的理由和深刻的理解，否则不要使用weakKeys()和weakValues()。对于大多数业务场景，强引用结合显式的过期和驱逐策略是更安全和可预测的选择。
正确管理缓存实例生命周期： 对于应用程序级别的共享缓存，务必将其声明为static final，或通过依赖注入框架将其配置为单例，以确保缓存实例的唯一性和持久性，从而保证缓存数据的可靠性和一致性。

通过遵循这些最佳实践，可以有效地利用Caffeine缓存的性能优势，同时避免因配置不当而导致的数据丢失问题。

Java Stream 中 findAny() 方法的非确定性行为解析

Java中的TimeUnit枚举类怎么用_时间单位转换与线程睡眠

Java中的BootstrapMethodError是什么原因_Lambda动态绑定失败

Java项目如何利用ThreadLocal保存用户上下文_在Filter中提取Token并向下层传递线程副本

怎么配置Java编程的JShell交互式环境_Java9新特性环境初探