在 Java 中，引用（Reference）机制用于管理对象的生命周期和垃圾回收。Java 提供了四种类型的引用：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。WeakHashMap 使用弱引用来存储键，从而在键不再被强引用引用时自动移除对应的条目。下面是 WeakHashMap 的使用方法以及四种引用的优缺点对比。
WeakHashMap 使用方法
基本概念
- 弱引用（Weak Reference）：弱引用不会阻止对象被垃圾回收。如果一个对象只被弱引用引用，并且没有其他强引用引用它，那么该对象在下一次垃圾回收时会被回收。
- 自动移除：当
WeakHashMap中的键被垃圾回收时，对应的键值对会自动从WeakHashMap中移除。
主要方法
WeakHashMap 实现了 Map 接口，因此它提供了 Map 接口中的所有方法，如 put, get, remove, containsKey, containsValue, size, isEmpty, clear 等。
示例代码
以下是一些常见的 WeakHashMap 使用示例：
1. 基本用法
import java.util.Map;
import java.util.WeakHashMap;
public class WeakHashMapExample {
public static void main(String[] args) {
Map<Key, String> weakMap = new WeakHashMap<>();
Key key1 = new Key("key1");
Key key2 = new Key("key2");
weakMap.put(key1, "Value1");
weakMap.put(key2, "Value2");
System.out.println("Initial WeakHashMap: " + weakMap);
// 清除强引用
key1 = null;
key2 = null;
// 强制进行垃圾回收
System.gc();
// 等待一段时间，确保垃圾回收完成
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("WeakHashMap after GC: " + weakMap);
}
static class Key {
private String id;
public Key(String id) {
this.id = id;
}
@Override
public String toString() {
return "Key{" + "id='" + id + "'}";
}
@Override
public int hashCode() {
return id.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Key key = (Key) obj;
return id.equals(key.id);
}
}
}
输出：
Initial WeakHashMap: {Key{id='key1'}=Value1, Key{id='key2'}=Value2}
WeakHashMap after GC: {}
解释：
- 创建了一个
WeakHashMap并添加了两个键值对。 - 清除了对键的强引用。
- 强制进行垃圾回收，并等待一段时间。
- 垃圾回收后，
WeakHashMap中的所有条目都被移除，因为键不再被强引用引用。
2. 使用弱引用的缓存
import java.util.Map;
import java.util.WeakHashMap;
public class WeakHashMapCacheExample {
public static void main(String[] args) {
Map<Key, String> cache = new WeakHashMap<>();
Key key1 = new Key("key1");
Key key2 = new Key("key2");
cache.put(key1, "Value1");
cache.put(key2, "Value2");
System.out.println("Initial Cache: " + cache);
// 清除对 key1 的强引用
key1 = null;
// 强制进行垃圾回收
System.gc();
// 等待一段时间，确保垃圾回收完成
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Cache after GC: " + cache);
// 重新获取 key2 的值
System.out.println("Value for key2: " + cache.get(key2));
}
static class Key {
private String id;
public Key(String id) {
this.id = id;
}
@Override
public String toString() {
return "Key{" + "id='" + id + "'}";
}
@Override
public int hashCode() {
return id.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Key key = (Key) obj;
return id.equals(key.id);
}
}
}
输出：
Initial Cache: {Key{id='key1'}=Value1, Key{id='key2'}=Value2}
Cache after GC: {Key{id='key2'}=Value2}
Value for key2: Value2
解释：
- 创建了一个
WeakHashMap作为缓存，并添加了两个键值对。 - 清除了对
key1的强引用。 - 强制进行垃圾回收，并等待一段时间。
- 垃圾回收后，
key1对应的条目被移除，而key2对应的条目仍然存在。 - 重新获取
key2的值，验证缓存中仍然存在该条目。
强引用、软引用、弱引用和虚引用的对比
强引用（Strong Reference）
- 定义：强引用是最常见的引用类型，只要对象有强引用，垃圾回收器就不会回收该对象。
- 使用场景：大多数对象使用强引用。
- 优点：
- 对象不会被垃圾回收，确保对象的生命周期。
- 缺点：
- 容易导致内存泄漏，因为对象不会被自动回收。
软引用（Soft Reference）
- 定义：软引用不会阻止对象被垃圾回收，但只有在内存不足时才会被回收。
- 使用场景：适用于实现内存敏感的缓存。
- 优点：
- 在内存不足时可以回收对象，避免内存溢出。
- 缺点：
- 对象的回收时间不可预测，可能导致缓存中的数据丢失。
- 需要额外的管理来处理软引用。
弱引用（Weak Reference）
- 定义：弱引用不会阻止对象被垃圾回收，只要对象没有其他强引用引用它，就会被回收。
- 使用场景：适用于实现缓存，避免内存泄漏。
- 优点：
- 对象的回收时间可预测，只要没有强引用引用对象，就会被回收。
- 自动管理内存，避免内存泄漏。
- 缺点：
- 对象的回收时间不可预测，可能导致缓存中的数据丢失。
- 需要额外的管理来处理弱引用。
虚引用（Phantom Reference）
- 定义：虚引用不会阻止对象被垃圾回收，主要用于跟踪对象的回收状态。
- 使用场景：适用于需要跟踪对象回收状态的场景。
- 优点：
- 可以跟踪对象的回收状态。
- 缺点：
- 无法通过虚引用访问对象。
- 需要配合引用队列（Reference Queue）使用。
对比表格
| 特性 | 强引用 (Strong Reference) | 软引用 (Soft Reference) | 弱引用 (Weak Reference) | 虚引用 (Phantom Reference) |
|---|---|---|---|---|
| 定义 | 最常见的引用类型 | 不阻止对象被垃圾回收，内存不足时回收 | 不阻止对象被垃圾回收，没有强引用时回收 | 不阻止对象被垃圾回收，主要用于跟踪对象回收状态 |
| 使用场景 | 大多数对象 | 内存敏感的缓存 | 缓存，避免内存泄漏 | 跟踪对象回收状态 |
| 优点 | 对象不会被垃圾回收 | 内存不足时回收对象，避免内存溢出 | 对象的回收时间可预测，自动管理内存 | 可以跟踪对象的回收状态 |
| 缺点 | 容易导致内存泄漏 | 对象的回收时间不可预测 | 对象的回收时间不可预测 | 无法通过虚引用访问对象 |
| 适用性 | 通用 | 内存敏感的应用 | 缓存管理 | 对象回收状态跟踪 |
| 实现类 | 无特殊类 | java.lang.ref.SoftReference | java.lang.ref.WeakReference | java.lang.ref.PhantomReference |
| 示例 | Object obj = new Object(); | SoftReference<Object> softRef = new SoftReference<>(new Object()); | WeakReference<Object> weakRef = new WeakReference<>(new Object()); | PhantomReference<Object> phantomRef = new PhantomReference<>(new Object(), new ReferenceQueue<>()); |
总结
- 强引用：最常见，确保对象不被垃圾回收，但可能导致内存泄漏。
- 软引用：适用于内存敏感的缓存，内存不足时回收对象。
- 弱引用：适用于缓存管理，自动管理内存，避免内存泄漏。
- 虚引用：用于跟踪对象的回收状态，无法访问对象。
通过理解这些引用类型及其优缺点，可以更好地管理对象的生命周期和内存使用，特别是在实现缓存和内存敏感的应用时。WeakHashMap 利用弱引用来实现自动内存管理，适用于需要缓存的场景。
