Java弱引用在缓存设计中的价值
核心原因
- 自动内存管理：弱引用允许垃圾回收器在内存不足时自动回收缓存对象，避免OOM
- 防止内存泄漏：缓存不会阻止对象被垃圾回收，避免长期持有不再使用的对象
- 平衡性能与资源：在内存充足时提供快速访问，内存紧张时自动释放
案例演示
import java.lang.ref.WeakReference;
import java.util.WeakHashMap;
// 案例1：使用WeakReference实现简单缓存
public class WeakCacheDemo {
// 使用WeakHashMap作为缓存容器
private static WeakHashMap<String, WeakReference<HeavyObject>> cache = new WeakHashMap<>();
static class HeavyObject {
private byte[] data = new byte[1024 * 1024]; // 1MB数据
private String name;
public HeavyObject(String name) {
this.name = name;
System.out.println("创建重型对象: " + name);
}
@Override
public String toString() {
return "HeavyObject{" + name + "}";
}
}
public static HeavyObject getObject(String key) {
WeakReference<HeavyObject> ref = cache.get(key);
if (ref != null) {
HeavyObject obj = ref.get();
if (obj != null) {
System.out.println("从缓存获取: " + key);
return obj;
} else {
System.out.println("缓存对象已被回收: " + key);
}
}
// 创建新对象并加入缓存
HeavyObject newObj = new HeavyObject(key);
cache.put(key, new WeakReference<>(newObj));
return newObj;
}
public static void main(String[] args) {
// 获取对象，创建并缓存
HeavyObject obj1 = getObject("object1");
// 再次获取，从缓存返回
HeavyObject obj2 = getObject("object1");
// 移除强引用，触发垃圾回收
obj1 = null;
obj2 = null;
System.out.println("触发垃圾回收...");
System.gc();
// 再次获取，由于对象被回收，会重新创建
HeavyObject obj3 = getObject("object1");
}
}
案例2：WeakHashMap的实际应用
import java.util.WeakHashMap;
// 使用WeakHashMap实现自动清理的缓存
public class WeakHashMapDemo {
private static WeakHashMap<String, Image> imageCache = new WeakHashMap<>();
static class Image {
private String name;
private byte[] pixels;
public Image(String name) {
this.name = name;
this.pixels = new byte[5 * 1024 * 1024]; // 5MB图片
System.out.println("加载图片: " + name);
}
@Override
public String toString() {
return "Image{" + name + "}";
}
}
public static Image loadImage(String path) {
Image img = imageCache.get(path);
if (img != null) {
System.out.println("使用缓存图片: " + path);
return img;
}
img = new Image(path);
imageCache.put(path, img);
return img;
}
public static void main(String[] args) {
// 加载图片
Image img1 = loadImage("/images/photo1.jpg");
Image img2 = loadImage("/images/photo2.jpg");
System.out.println("缓存大小: " + imageCache.size());
// 释放强引用
img1 = null;
img2 = null;
// 模拟内存压力
System.out.println("模拟内存压力...");
for (int i = 0; i < 10; i++) {
byte[] temp = new byte[10 * 1024 * 1024];
if (i == 5) {
System.gc();
System.out.println("垃圾回收后缓存大小: " + imageCache.size());
}
}
// 缓存中的图片已被自动清理
System.out.println("最终缓存大小: " + imageCache.size());
}
}
与强引用缓存对比
// 问题：使用强引用导致内存泄漏
public class BadCacheExample {
private static HashMap<String, BigObject> cache = new HashMap<>();
static class BigObject {
private int[] data = new int[1000000]; // 约4MB
}
public static BigObject getObject(String key) {
BigObject obj = cache.get(key);
if (obj == null) {
obj = new BigObject();
cache.put(key, obj);
}
return obj;
}
// 即使外部不再使用，对象仍然被缓存持有
// 长时间运行会导致OutOfMemoryError
}
最佳实践建议
-
适用场景：
- 可重建的缓存数据（如从数据库计算得出）
- 非关键性缓存（丢失后可以重新获取）
- 大对象缓存（如图片、文档）
-
注意事项：
- 弱引用不保证对象存活时间
- 不适合存储必须持久化的数据
- 适合配合引用队列(ReferenceQueue)使用
-
替代方案：
- ThreadLocal：线程级缓存
- SoftReference：比弱引用更强的引用，适合更持久的缓存
- 专门缓存框架：如Guava Cache、Caffeine
弱引用在缓存设计中特别有用，因为它既提供了缓存的便利性，又不会阻止垃圾回收器回收不再使用的对象,实现了内存使用和性能的良好平衡。
