使用软引用实现缓存的核心做法是创建一个包装了软引用的容器,在获取缓存时先尝试从软引用中取值,若取不到(即被gc回收)则重新计算并放入新的软引用中。具体实现需要引入 java.lang.ref.softreference 类,并在业务逻辑中处理空值判断与重建逻辑。这样做的好处是利用 jvm 的内存压力自动淘汰缓存,避免手动管理过期策略的复杂性,同时保证在内存充足时缓存依然有效。

如何构建支持软引用的缓存结构
构建缓存结构的关键在于将实际数据对象包裹在 SoftReference 中,并使用一个线程安全的集合(如 ConcurrentHashMap)来存储这些引用。当请求数据时,先从 Map 中取出 SoftReference,然后调用其 get() 方法。如果返回非空,说明数据仍在内存中且未被回收,直接返回;如果返回 null,说明数据已被 GC 回收,此时需要执行数据加载逻辑,并将新数据再次包装为 SoftReference 存入 Map 以替换旧的引用。
import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentHashMap;
public class SoftRefCache {
private final ConcurrentHashMap<String, SoftReference<Object>> cache = new ConcurrentHashMap<>();
public Object getOrLoad(String key) {
// 1. 尝试从缓存中获取软引用
SoftReference<Object> ref = cache.get(key);
if (ref != null) {
Object value = ref.get();
if (value != null) {
return value; // 缓存命中
}
// 如果 ref.get() 为 null,说明已被回收,需移除旧引用
cache.remove(key, ref);
}
// 2. 缓存未命中或已回收,加载数据
Object newValue = loadDataFromSource(key);
// 3. 将新数据包装为软引用并存入缓存
cache.put(key, new SoftReference<>(newValue));
return newValue;
}
private Object loadDataFromSource(String key) {
// 模拟耗时数据加载
return "Data for " + key;
}
}上述代码展示了基本的缓存获取流程。注意在 ref.get() 返回 null 后,必须调用 cache.remove(key, ref) 清理失效的引用,否则 Map 中会堆积大量指向 null 的垃圾对象,导致内存泄漏和性能下降。这种结构简单且高效,适合对一致性要求不高、允许偶尔重算的场景。

立即学习“Java免费学习笔记(深入)”;
FilePond 是一个 JavaScript 文件上传库,支持通过拖拽、粘贴和 API 方式处理文件、目录、URL 和 Data URI。它包含内置的图像优化功能、异步分块上传功能,并提供了适用于 React、Vue、Angular 和 Svelte 的适配器。
软引用缓存与强引用缓存的行为差异
软引用缓存与强引用缓存的主要区别在于内存不足时的行为表现。强引用缓存(如普通 HashMap 存储对象)在内存不足时会抛出 OutOfMemoryError,因为对象无法被 GC 回收。而软引用缓存在 JVM 堆内存不足时,GC 会优先回收软引用指向的对象,从而释放内存,程序通常不会崩溃,而是触发缓存重建。为了验证这一差异,我们可以编写一个对比测试,分别使用强引用和软引用存储大量数据,并观察在低内存环境下的表现。
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;
public class CacheComparison {
public static void main(String[] args) {
// 强引用缓存
Map<String, String> strongCache = new HashMap<>();
// 软引用缓存
Map<String, SoftReference<String>> softCache = new HashMap<>();
// 填充数据
for (int i = 0; i < 10000; i++) {
String data = "Data" + i;
strongCache.put("key" + i, data);
softCache.put("key" + i, new SoftReference<>(data));
}
// 触发 GC 并检查软引用状态
System.gc();
try { Thread.sleep(100); } catch (InterruptedException e) {}
int softHitCount = 0;
for (int i = 0; i < 10000; i++) {
SoftReference<String> ref = softCache.get("key" + i);
if (ref != null && ref.get() != null) {
softHitCount++;
}
}
System.out.println("Soft cache hits after GC: " + softHitCount);
// 强引用缓存中的元素数量不变
System.out.println("Strong cache size: " + strongCache.size());
}
}运行上述代码,你会发现强引用缓存的大小始终为 10000,而软引用缓存的命中数会显著减少,甚至可能全部为 0,这取决于 JVM 的堆大小和 GC 策略。这表明软引用确实起到了“内存敏感”的作用,当内存紧张时,它会自动让出空间。在实际开发中,这种特性非常适合用于存储大型图片、临时计算结果等可以重新生成的数据。

软引用在特定输入下的回收时机
软引用的回收时机取决于 JVM 的内存分配策略。具体来说,当 JVM 在分配新对象时发现内存不足,且通过 GC 仍无法获得足够空间时,才会回收软引用。这意味着软引用并非在每次 GC 时都被回收,而是在“真正需要内存”时才被回收。为了验证这一点,我们可以构造一个场景:先填充软引用缓存,然后尝试分配大量内存,观察缓存是否被清空。如果内存充足,软引用将保持不变;如果内存紧张,软引用将被清除。
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;
public class SoftRefRecycleTest {
public static void main(String[] args) {
Map<String, SoftReference<byte[]>> cache = new HashMap<>();
// 1. 存入一些数据
byte[] largeData = new byte[1024 * 1024]; // 1MB
cache.put("large", new SoftReference<>(largeData));
// 2. 检查是否还在
System.out.println("Before allocation: " + (cache.get("large").get() != null));
// 3. 尝试分配更多内存,迫使 GC 回收软引用
try {
// 分配 50MB,假设堆空间不足以容纳
byte[] hugeData = new byte[50 * 1024 * 1024];
} catch (OutOfMemoryError e) {
// 即使 OOM,软引用也可能已被回收
}
// 4. 再次检查
System.out.println("After allocation attempt: " + (cache.get("large").get() != null));
}
}在这个测试中,如果 JVM 堆设置较小,第三步的内存分配尝试可能会触发 GC,从而导致第一步存入的 1MB 数据被回收。输出结果将从 true 变为 false,证明软引用在内存压力下被及时清理。这种机制使得软引用成为实现自适应缓存的理想选择,无需开发者手动干预回收策略,JVM 会根据当前内存状况自动优化缓存命中率与内存占用的平衡。

















