本文深入探讨了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<Long, SmsData> 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实例也会随之被回收，导致缓存中的所有数据丢失。这在分布式系统或高并发场景下尤其容易引发问题，因为不同的请求可能会创建不同的服务实例，每个实例都有自己的缓存，导致数据不一致或丢失。
// 示例：一个非static的缓存可能面临的问题
public class ShortLivedService {
// 这是一个实例级别的缓存，它的生命周期与ShortLivedService实例绑定
private Cache<Long, SmsData> 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缓存中值意外丢失的问题，推荐的解决方案是：
- 将Cache实例声明为static final，确保其具有与应用程序相同的生命周期，并作为应用程序的全局共享资源。
- 移除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<Long, SmsData> 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 { 
