java的WeakHashMap可以用来做缓存使用？强软弱虚四种引用对比

在 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;}@Overridepublic String toString() {return "Key{" + "id='" + id + "'}";}@Overridepublic int hashCode() {return id.hashCode();}@Overridepublic 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;}@Overridepublic String toString() {return "Key{" + "id='" + id + "'}";}@Overridepublic int hashCode() {return id.hashCode();}@Overridepublic 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<>());`