关于后端:理解Java的强引用软引用弱引用和虚引用

前言
Java 执行 GC 判断对象是否存活有两种形式其中一种是援用计数。

援用计数：Java 堆中每一个对象都有一个援用计数属性，援用每新增 1 次计数加 1，援用每开释 1 次计数减 1。

在 JDK 1.2 以前的版本中，若一个对象不被任何变量援用，那么程序就无奈再应用这个对象。也就是说，只有对象处于 (reachable) 可达状态，程序能力应用它。
从 JDK 1.2 版本开始，对象的援用被划分为 4 种级别，从而使程序能更加灵便地管制对象的生命周期。这 4 种级别由高到低顺次为：强援用、软援用、弱援用和虚援用。

注释

1. 强援用 (StrongReference)
   强援用是应用最广泛的援用。如果一个对象具备强援用，那垃圾回收器绝不会回收它。如下：
   Object strongReference = new Object();
   复制代码当内存空间有余时，Java 虚拟机宁愿抛出 OutOfMemoryError 谬误，使程序异样终止，也不会靠随便回收具备强援用的对象来解决内存不足的问题。
   如果强援用对象不应用时，须要弱化从而使 GC 可能回收，如下：
   strongReference = null;
   复制代码显式地设置 strongReference 对象为 null，或让其超出对象的生命周期范畴，则 gc 认为该对象不存在援用，这时就能够回收这个对象。具体什么时候收集这要取决于 GC 算法。
   public void test() {

    Object strongReference = new Object();
    // 省略其余操作

   }
   复制代码在一个办法的外部有一个强援用，这个援用保留在 Java 栈中，而真正的援用内容 (Object) 保留在 Java 堆中。
   当这个办法运行实现后，就会退出办法栈，则援用对象的援用数为 0，这个对象会被回收。
   然而如果这个 strongReference 是全局变量时，就须要在不必这个对象时赋值为 null，因为强援用不会被垃圾回收。
   ArrayList 的 Clear 办法：

在 ArrayList 类中定义了一个 elementData 数组，在调用 clear 办法清空数组时，每个数组元素被赋值为 null。
不同于 elementData=null，强援用依然存在，防止在后续调用 add()等办法增加元素时进行内存的重新分配。
应用如 clear()办法内存数组中寄存的援用类型进行内存开释特地实用，这样就能够及时开释内存。

2. 软援用 (SoftReference)
   如果一个对象只具备软援用，则内存空间短缺时，垃圾回收器就不会回收它；如果内存空间有余了，就会回收这些对象的内存。只有垃圾回收器没有回收它，该对象就能够被程序应用。

软援用可用来实现内存敏感的高速缓存。

// 强援用
String strongReference = new String("abc");
// 软援用
String str = new String("abc");
SoftReference<String> softReference = new SoftReference<String>(str);

复制代码软援用能够和一个援用队列 (ReferenceQueue) 联结应用。如果软援用所援用对象被垃圾回收，JAVA 虚拟机就会把这个软援用退出到与之关联的援用队列中。

ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
String str = new String("abc");
SoftReference<String> softReference = new SoftReference<>(str, referenceQueue);

str = null;
// Notify GC
System.gc();

System.out.println(softReference.get()); // abc

Reference<? extends String> reference = referenceQueue.poll();
System.out.println(reference); //null

复制代码
留神：软援用对象是在 jvm 内存不够的时候才会被回收，咱们调用 System.gc()办法只是起告诉作用，JVM 什么时候扫描回收对象是 JVM 本人的状态决定的。就算扫描到软援用对象也不肯定会回收它，只有内存不够的时候才会回收。

当内存不足时，JVM 首先将软援用中的对象援用置为 null，而后告诉垃圾回收器进行回收：

if(JVM 内存不足) {
    // 将软援用中的对象援用置为 null
    str = null;
    // 告诉垃圾回收器进行回收
    System.gc();}

复制代码也就是说，垃圾收集线程会在虚拟机抛出 OutOfMemoryError 之前回收软援用对象，而且虚构机会尽可能优先回收长时间闲置不用的软援用对象。对那些刚构建的或刚应用过的 “ 较新的 ” 软对象会被虚拟机尽可能保留，这就是引入援用队列 ReferenceQueue 的起因。
利用场景：
浏览器的后退按钮。按后退时，这个后退时显示的网页内容是从新进行申请还是从缓存中取出呢？这就要看具体的实现策略了。

如果一个网页在浏览完结时就进行内容的回收，则按后退查看后面浏览过的页面时，须要从新构建；
如果将浏览过的网页存储到内存中会造成内存的大量节约，甚至会造成内存溢出。

这时候就能够应用软援用，很好的解决了理论的问题：

// 获取浏览器对象进行浏览
Browser browser = new Browser();
// 从后台程序加载浏览页面
BrowserPage page = browser.getPage();
// 将浏览结束的页面置为软援用
SoftReference softReference = new SoftReference(page);

// 回退或者再次浏览此页面时
if(softReference.get() != null) {
    // 内存短缺，还没有被回收器回收，间接获取缓存
    page = softReference.get();} else {
    // 内存不足，软援用的对象曾经回收
    page = browser.getPage();
    // 从新构建软援用
    softReference = new SoftReference(page);
}

复制代码 3. 弱援用 (WeakReference)
弱援用与软援用的区别在于：只具备弱援用的对象领有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具备弱援用的对象，不论以后内存空间足够与否，都会回收它的内存。不过，因为垃圾回收器是一个优先级很低的线程，因而不肯定会很快发现那些只具备弱援用的对象。

String str = new String("abc");
WeakReference<String> weakReference = new WeakReference<>(str);
str = null;

复制代码 JVM 首先将软援用中的对象援用置为 null，而后告诉垃圾回收器进行回收：

str = null;
System.gc();

复制代码
留神：如果一个对象是偶然 (很少) 的应用，并且心愿在应用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用 Weak Reference 来记住此对象。

上面的代码会让一个弱援用再次变为一个强援用：

String str = new String("abc");
WeakReference<String> weakReference = new WeakReference<>(str);
// 弱援用转强援用
String strongReference = weakReference.get();

复制代码同样，弱援用能够和一个援用队列 (ReferenceQueue) 联结应用，如果弱援用所援用的对象被垃圾回收，Java 虚拟机就会把这个弱援用退出到与之关联的援用队列中。
简略测试：
GCTarget.java
public class GCTarget {

// 对象的 ID
public String id;

// 占用内存空间
byte[] buffer = new byte[1024];

public GCTarget(String id) {this.id = id;}

protected void finalize() throws Throwable {
    // 执行垃圾回收时打印显示对象 ID
    System.out.println("Finalizing GCTarget, id is :" + id);
}

}
复制代码 GCTargetWeakReference.java
public class GCTargetWeakReference extends WeakReference<GCTarget> {

// 弱援用的 ID
public String id;

public GCTargetWeakReference(GCTarget gcTarget,
          ReferenceQueue<? super GCTarget> queue) {super(gcTarget, queue);
    this.id = gcTarget.id;
}

protected void finalize() {System.out.println("Finalizing GCTargetWeakReference" + id);
}

}
复制代码 WeakReferenceTest.java
public class WeakReferenceTest {

// 弱援用队列
private final static ReferenceQueue<GCTarget> REFERENCE_QUEUE = new ReferenceQueue<>();

public static void main(String[] args) {LinkedList<GCTargetWeakReference> gcTargetList = new LinkedList<>();

    // 创立弱援用的对象，顺次退出链表中
    for (int i = 0; i < 5; i++) {GCTarget gcTarget = new GCTarget(String.valueOf(i));
        GCTargetWeakReference weakReference = new GCTargetWeakReference(gcTarget,
            REFERENCE_QUEUE);
        gcTargetList.add(weakReference);

        System.out.println("Just created GCTargetWeakReference obj:" +
            gcTargetList.getLast());
    }

    // 告诉 GC 进行垃圾回收
    System.gc();

    try {
        // 劳动几分钟，期待下面的垃圾回收线程运行实现
        Thread.sleep(6000);
    } catch (InterruptedException e) {e.printStackTrace();
    }

    // 查看关联的援用队列是否为空
    Reference<? extends GCTarget> reference;
    while((reference = REFERENCE_QUEUE.poll()) != null) {if(reference instanceof GCTargetWeakReference) {
            System.out.println("In queue, id is:" +
                ((GCTargetWeakReference) (reference)).id);
        }
    }
}

}
复制代码运行 WeakReferenceTest.java，运行后果如下：

可见 WeakReference 对象的生命周期根本由垃圾回收器决定，一旦垃圾回收线程发现了弱援用对象，在下一次 GC 过程中就会对其进行回收。

4. 虚援用 (PhantomReference)
   虚援用顾名思义，就是形同虚设。与其余几种援用都不同，虚援用并不会决定对象的生命周期。如果一个对象仅持有虚援用，那么它就和没有任何援用一样，在任何时候都可能被垃圾回收器回收。
   利用场景：
   虚援用次要用来跟踪对象被垃圾回收器回收的流动。
   虚援用与软援用和弱援用的一个区别在于：

虚援用必须和援用队列 (ReferenceQueue) 联结应用。当垃圾回收器筹备回收一个对象时，如果发现它还有虚援用，就会在回收对象的内存之前，把这个虚援用退出到与之关联的援用队列中。

String str = new String("abc");
ReferenceQueue queue = new ReferenceQueue();
// 创立虚援用，要求必须与一个援用队列关联
PhantomReference pr = new PhantomReference(str, queue);

复制代码程序能够通过判断援用队列中是否曾经退出了虚援用，来理解被援用的对象是否将要进行垃圾回收。如果程序发现某个虚援用曾经被退出到援用队列，那么就能够在所援用的对象的内存被回收之前采取必要的口头。
总结

Java 中 4 种援用的级别和强度由高到低顺次为：强援用 -> 软援用 -> 弱援用 -> 虚援用

当垃圾回收器回收时，某些对象会被回收，某些不会被回收。垃圾回收器会从根对象 Object 来标记存活的对象，而后将某些不可达的对象和一些援用的对象进行回收。
通过表格来阐明一下，如下：

援用类型
被垃圾回收工夫
用处
生存工夫

强援用
从来不会
对象的个别状态
JVM 进行运行时终止

软援用
当内存不足时
对象缓存
内存不足时终止

弱援用
失常垃圾回收时
对象缓存
垃圾回收后终止

虚援用
失常垃圾回收时
跟踪对象的垃圾回收
垃圾回收后终止