介绍
JAVA 中有 4 种类型的引用：
– 强引用
– 软引用
– 弱引用
– 幻像引用
这些引用的区别仅在于 垃圾回收器 管理它们的方式。如果你从未听说过它们，这意味着你只使用强大的。了解差异可以帮助您，特别是如果您需要存储临时对象并且无法使用真正的缓存库（如eHcache或Guava）。
由于这些类型与 JVM 垃圾回收器密切相关，因此我将简要回顾一下有关 JAVA 中垃圾回收的一些信息，然后介绍不同的类型。
垃圾回收器
Java和C++之间的主要区别在于 内存管理 。在Java中，开发人员不需要知道内存是如何工作的（但他应该知道！），因为JVM通过其垃圾回收器来处理这一部分。
创建对象时，它由 JVM 在其 堆 中分配。堆是内存中的有限空间量。因此，JVM 通常需要删除对象才能释放空间。要销毁对象，JVM 需要知道此对象是处于活动状态还是非活动状态。如果对象被 垃圾回收root 引用（传递），则该对象仍在使用中。
例如：
- 如果对象 C 由对象 B 引用，B 由对象 A 引用，A 由垃圾回收root引用，则 C、B 和 A 被视为活动（情况 1）。
- 但是，如果 A 不再引用 B，则 C 和 B 不再处于活动状态，可以销毁（案例 2）。
由于这篇文章不是关于垃圾收集器的，我不会在解释中深入介绍，但仅供参考，有4种类型的垃圾收集root：
- 局部变量
- 活动 Java 线程
- 静态变量
- JNI 引用 ，这些 Java 对象包含本机代码，而不是由 jvm 管理的内存
Oracle 没有指定如何管理内存，因此每个 JVM 实现都有自己的一组算法。但这个想法总是一样的：
- JVM使用一种递归算法来查找非活动对象并标记它们
- 标记的对象被最终确定（调用finize（）方法）然后销毁
- JVM有时会移动剩余对象的一部分，以便在堆中重建大面积的自由连续空间
问题
如果JVM管理内存，你为什么需要关心？因为这并不意味着你不能有 内存泄漏 ！
大多数情况下，您在没有意识到的情况下使用垃圾回收根目录。例如，假设您需要在程序的生命周期内存储一些 objet（因为它们的初始化成本很高）。您可能会使用静态整理（List、Map 等）来存储和检索代码中任何位置的这些对象：
public static Map<K, V> myStoredObjects= new HashMap<>();
但是，通过这样做，可以防止 JVM 破坏集合中的对象。通过错误，你可能会和一个 超出记忆 的错误。例如：
public class OOM {
public static List<Integer> myCachedObjects = new ArrayList<>();
public static void main(String[] args) {
for (int i = 0; i < 100_000_000; i++) {
myCachedObjects.add(i);
}
}
}
输出为：
线程“main” java.lang.OutOfMemoryError中的异常：Java heap space
Java提供了不同类型的引用来避免OutOfMemoryError。
某些类型允许 JVM 释放对象，即使程序仍然需要这些对象。开发人员有责任处理这些情况。
强引用
强参考是标准参考。当你在对象 obj 上创建这样的内容时：
MyClass obj = new MyClass ();
您正在创建一个名为“obj”的强引用，该引用指向新创建的 MyClass 实例。当垃圾回收器查找非活动对象时，它只检查 objets 是否 强可访问 ，这意味着通过强引用传递链接到垃圾回收根。
使用此类型的引用会强制 JVM 将对象保留在堆中，直到未按照“垃圾回收器”一节中所述使用对象为止。
软引用
根据java API的软参考有：
“软引用对象，由垃圾回收器自行决定清除，以响应内存需求”
这意味着，如果您在不同的JVM上运行程序，软引用的行为可能会改变（Oracle的Hotspot，Oracle的JRockit，IBM的J9等）。
让我们来看看Oracle的JVM Hotspot（标准和最常用的JVM），看看它如何管理软引用。根据甲骨文文档：
“默认值为每兆字节 1000 毫秒，这意味着对于堆中每 MB 的可用空间，软引用将存活 1 秒（在收集了对对象的最后一个强引用之后）”
下面是一个具体示例：让我们假设堆是 512 MB，有 400MB 可用。
我们创建一个对象 A ，软引用对象 缓存 ，强引用 A 到对象 B 。由于 A 强烈引用 B ，因此它非常可访问，并且不会被垃圾回收器删除（情况 1）。
想象一下，现在 B 已被删除，因此 A 仅被软引用到 缓存 对象。如果对象 A 在接下来的 400 秒内未被强烈引用，则会在超时后将其删除（情况 2）。
以下是操作软引用的方法：
public class ExampleSoftRef {
public static class A{
}
public static class B{
private A strongRef;
public void setStrongRef(A ref) {
this.strongRef = ref;
}
}
public static SoftReference<A> cache;
public static void main(String[] args) throws InterruptedException{
//用软instanceA的引用的缓存的初始化
ExampleSoftRef.A instanceA = new ExampleSoftRef.A();
cache = new SoftReference<ExampleSoftRef.A>(instanceA);
instanceA=null;
// 现在instanceA是只软可到达的且可以在一段时间后，由垃圾回收器删除
Thread.sleep(5000);
...
ExampleSoftRef.B instanceB = new ExampleSoftRef.B();
//从缓存具有软引用的实例后，我们不能肯定instanceA仍然存在
//如果需要，我们需要检查并重新创建instanceA
instanceA=cache.get();
if (instanceA ==null){
instanceA = new ExampleSoftRef.A();
cache = new SoftReference<ExampleSoftRef.A>(instanceA);
}
instanceB.setStrongRef(instanceA);
instanceA=null;
// instanceA现在只是轻轻地由缓存引用和强烈引用，所以它不能是clea
...
}
}
但是，即使垃圾回收器自动删除了软引用对象， 软引用 （也是对象）**也不会被删除！**因此，您仍然需要清除它们。例如，对于像 64 MB （Xmx64m） 这样的低堆大小，下面的代码给出了一个 OutOfMemoryException，尽管使用了软引用。
public class TestSoftReference1 {
public static class MyBigObject{
//each instance has 128 bytes of data
int[] data = new int[128];
}
public static int CACHE_INITIAL_CAPACITY = 1_000_000;
public static Set<SoftReference<MyBigObject>> cache = new HashSet<>(CACHE_INITIAL_CAPACITY);
public static void main(String[] args) {
for (int i = 0; i < 1_000_000; i++) {
MyBigObject obj = new MyBigObject();
cache.add(new SoftReference<>(obj));
if (i%200_000 == 0){
System.out.println("size of cache:" + cache.size());
}
}
System.out.println("End");
}
}
输出代码为：
缓存大小：1
缓存大小：200001
缓存大小：400001
缓存大小：600001
线程“主”中的异常 java.lang.OutOfMemoryError： 超出 GC 开销限制
Oracle 提供了一个 ReferenceQueue ，当引用的对象只能软访问时，该队列会填充软引用。使用此队列，您可以清除软引用并避免超出内存错误。
使用 ReferenceQueue，与上面相同的代码具有相同的堆大小（64 MB），但要存储的数据更多（500 万对 100 万），可以工作：
public class TestSoftReference2 {
public static int removedSoftRefs = 0;
public static class MyBigObject {
//each instance has 128 bytes of data
int[] data = new int[128];
}
public static int CACHE_INITIAL_CAPACITY = 1_000_000;
public static Set<SoftReference<MyBigObject>> cache = new HashSet<>(
CACHE_INITIAL_CAPACITY);
public static ReferenceQueue<MyBigObject> unusedRefToDelete = new ReferenceQueue<>();
public static void main(String[] args) {
for (int i = 0; i < 5_000_000; i++) {
MyBigObject obj = new MyBigObject();
cache.add(new SoftReference<>(obj, unusedRefToDelete));
clearUselessReferences();
}
System.out.println("End, removed soft references=" + removedSoftRefs);
}
public static void clearUselessReferences() {
Reference<? extends MyBigObject> ref = unusedRefToDelete.poll();
while (ref != null) {
if (cache.remove(ref)) {
removedSoftRefs++;
}
ref = unusedRefToDelete.poll();
}
}
}
输出为：
结束，删除的软引用 = 4976899
当您需要存储许多对象时，软引用非常有用，如果这些对象被 JVM 删除，这些对象可能会（代价高昂）地重新实例化。
弱引用
弱参考是一个比软参考更易失性的概念。根据JAVA API：
“假设垃圾回收器在某个时间点确定某个对象是弱可访问的。届时，它将原子清除对该对象的所有弱引用，以及对任何其他弱可访问对象的所有弱引用，该对象可通过强引用和软引用链访问。同时，它将声明所有以前弱可访问的对象都是可最终确定的。在同一时间或稍后的某个时间，它将把那些新清除的弱引用排入参考队列。
这意味着，当垃圾回收器检查所有对象时，如果它检测到的对象仅具有对垃圾回收根的弱引用（即没有链接到该对象的强引用或软引用），则该对象将被标记为删除并尽快删除。使用弱引用的方式与使用软引用完全相同。因此，请看部分“软引用”中的示例。
Oracle提供了一个基于弱引用的非常有趣的类：WeakHashMap。此映射具有具有弱引用键的特殊性。WeakHashMap可以用作标准Map。唯一的区别是，它将在从堆中销毁密钥后 自动清除：
public class ExampleWeakHashMap {
public static Map<Integer,String> cache = new WeakHashMap<Integer, String>();
public static void main(String[] args) {
Integer i5 = new Integer(5);
cache.put(i5, "five");
i5=null;
//输入{5，"five"}将留在地图，直到下一个垃圾回收器调用
Integer i2 = 2;
//输入{2，"two"}将留在地图，直到i2强引用
cache.put(i2, "two");
//remebmber内存溢出错误在第二章"problem"，这次不会发生
//因为Map，将清除它的条目。
for (int i = 6; i < 100_000_000; i++) {
cache.put(i,String.valueOf(i));
}
}
}
例如，我使用 WeakHashMap 解决了以下问题：存储事务的多个信息。我使用了这个结构：WeakHashMap<String，Map<K，V>>其中，WeakHashMap的键是一个包含事务Id的字符串，而“简单”Map是我在事务生命周期内需要保留的信息。有了这个结构，我肯定会在WeakHashMap中获取我的信息，因为包含事务ID的字符串在事务结束之前无法销毁，我不必关心清理Map。
Oracle建议使用WeakHashMap作为“规范化”映射。
幻像引用
在垃圾回收过程中，没有对垃圾回收根的强/软引用的对象将被删除。在删除之前，将调用方法 finalize（）。当对象最终确定但尚未删除时，它将变为“幻像可访问”，这意味着对象和垃圾回收根之间只有幻像引用。
与软引用和弱引用不同，对对象使用显式幻像引用可防止删除对象。程序员需要显式或隐式删除幻像引用，以便可以销毁最终确定的对象。要显式清除幻像引用，程序员需要使用 ReferenceQueue ，该队列在对象最终确定时用幻像引用填充。
幻像引用无法检索被引用的对象：幻像引用的 get（） 方法始终返回 null，以便程序员无法使幻像可访问对象再次强/软/弱可访问。这是有道理的，因为幻像可访问对象已经完成，因此如果例如覆盖的finize（）函数已清除资源，则它不再起作用。
我不明白幻像引用如何有用，因为无法访问引用的对象。一个用例可能是，如果您需要在对象最终确定后执行操作，并且您无法（或出于性能原因不想）在此对象的fineize（）方法中执行特定操作。
结论
我希望您现在对这些参考资料有了更好的了解。大多数情况下，您不需要显式使用它们（也不应该使用它们）。但是，许多框架都在使用它们。如果你想了解事物是如何工作的，那么了解这个概念是件好事。
- 如果对大家有帮助，请三连支持一下！
- 有问题欢迎评论区留言，及时帮大家解决！
