本教程深入探讨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 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通常用于创建应用程序范围内的单例缓存实例，确保其在应用程序整个生命周期中只存在一个，并且数据能够被所有需要的地方访问和共享。
解决方案与最佳实践
综合上述分析，解决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 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缓存的性能优势，同时避免因配置不当而导致的数据丢失问题。
