背景

最近讀了寒泉子關(guān)于Finalizer的分享 JVM源碼分析之FinalReference完全解讀 - InfoQ
結(jié)合之前對java引用類型的了解，突然想到幾個開腦洞的問題：

• 如果一個對象沒有強引用，但是同時有軟引用和弱引用，或者同時有弱引用和虛引用，甚至三者同時出現(xiàn)，會發(fā)生什么？
• finalize方法和虛引用都可以作為資源回收的最后最后防線，那么它們的區(qū)別是什么？它們同時存在會怎么樣？

原理回顧

• 強引用（StrongReference）：就是我們平時用的等號賦值
• 軟引用（SoftReference）：當(dāng)對象只有軟引用，內(nèi)存不足時可以被回收，同時可以把Reference對象塞入ReferenceQueue
• 弱引用：當(dāng)對象只有弱引用，發(fā)生GC時可以被回收，同時可以把Reference對象塞入ReferenceQueue
• 虛引用（WeakReference）：相當(dāng)于沒有引用，get方法一直返回null，發(fā)生GC時可以被回收，同時可以把Reference對象塞入ReferenceQueue
• FinalizerReference：實現(xiàn)finalize方法的對象執(zhí)行完構(gòu)造方法都會被FinalizerReference包裝，并加入到 Finalizer 的靜態(tài)鏈表中，當(dāng)發(fā)生GC時，refrence被塞進ReferenceQueue隊列，由FinalizerThread線程取出，將reference從靜態(tài)鏈表解除，并執(zhí)行對象的finalize方法（注意：此時對象引用還在，所以逃過一次GC）

實驗思路

我們是想驗證各個引用類型進入隊列的順序，所以需要綁定到同一個ReferenceQueue，實現(xiàn)方式是利用反射把Finalizer里面的queue靜態(tài)屬性拿出來

    static ReferenceQueue getFinalizerRefrenceQueue() throws ClassNotFoundException, IllegalAccessException {
        Class<?> cls = Class.forName("java.lang.ref.Finalizer");
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            if (field.getType() == ReferenceQueue.class && Modifier.isStatic(field.getModifiers())) {
                return (ReferenceQueue) field.get(cls);
            }
        }
        return null;
    }

另外FinalizerThread一直在跑，會造成干擾，我們要把這個線程stop掉，我們自己實現(xiàn)一個線程串行來消費隊列里的元素

    static void stopFinalizerThread(){
        for(Thread t: Thread.getAllStackTraces().keySet()) {
            if (t.getName().equals("Finalizer")) {
                t.stop();
            }
        }
    }

消費線程：

   static class Consumer implements Runnable {
        @Override
        public void run() {
            for (; ; ) {
                try {
                    Reference ref = queue.remove();
                    if (ref.get() != null && ref.getClass().getSimpleName().equals("Finalizer")) { //Finalizer代替Finalizer線程執(zhí)行runFinalizer方法
                        Method runFinalizer = ref.getClass().getDeclaredMethod("runFinalizer", JavaLangAccess.class);
                        if (runFinalizer != null) {
                            runFinalizer.setAccessible(true);
                            runFinalizer.invoke(ref, SharedSecrets.getJavaLangAccess());
                        }
                    } else {//非Finalizer打印reference
                        System.out.printf("%s 加入引用隊列, ref.get:%s%n", ref, ref.get());
                        System.out.printf("%s get %s%n", softReference, softReference == null ? null : softReference.get());
                        System.out.printf("%s get %s%n", weakReference, weakReference.get());
                        System.out.printf("%s get %s%n", phantomReference, phantomReference.get());
                    }
                } catch (NoSuchMethodException e) {

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

實驗一

由于軟引用比較難觸發(fā)，所以實驗一先排除它。我們寫Main方法測試下

package reference;

import sun.misc.JavaLangAccess;
import sun.misc.SharedSecrets;

import java.lang.ref.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReferenceTest {
    static SoftReference<TestObject> softReference = null;
    static WeakReference<TestObject> weakReference = null;
    static PhantomReference<TestObject> phantomReference = null;
    static ReferenceQueue queue = null;

    public static void main(String[] args) throws Exception {
        TestObject test = new TestObject();
        stopFinalizerThread();
        queue = getFinalizerRefrenceQueue();
        Thread moniterThread = new Thread(new Consumer());
        moniterThread.start();
        weakReference = new WeakReference<TestObject>(test, queue);
        phantomReference = new PhantomReference<TestObject>(test, queue);

        test = null;// 去除強引用

        System.out.println(">> 第一次gc <<");
        System.gc();
        Thread.sleep(1000);
        System.out.println("\n>> 第二次gc <<");
        System.gc();
        Thread.sleep(1000);
    }

    public static class TestObject {
        @Override
        protected void finalize() throws Throwable {
            System.out.println("== finalize() ==");
        }
    }
  ...
}

結(jié)果

>> 第一次gc <<
java.lang.ref.WeakReference@262caf93 加入引用隊列, ref.get:null
null get null
java.lang.ref.WeakReference@262caf93 get null
java.lang.ref.PhantomReference@31fa332f get null
== finalize() ==

>> 第二次gc <<
java.lang.ref.PhantomReference@31fa332f 加入引用隊列, ref.get:null
null get null
java.lang.ref.WeakReference@262caf93 get null
java.lang.ref.PhantomReference@31fa332f get null

可以看到第一次GC后先處理WeakReference，然后處理Finalizer，此時TestObject對象逃過了一次GC（因為剛從Finalizer靜態(tài)鏈條上解除）；第二次GC后PhantomReference進入隊列；并且第一次GC后WeakReference和PhantomReference就get不到對象了

實驗二

為了觸發(fā)軟引用，我們需要申請一塊大內(nèi)存，看下面改造后的main方法，再加上 -Xmx128m -Xms128m -Xmn28m 啟動參數(shù)

    public static void main(String[] args) throws Exception {
        TestObject test = new TestObject();
        stopFinalizerThread();
        queue = getFinalizerRefrenceQueue();
        Thread moniterThread = new Thread(new Consumer());
        moniterThread.start();
        softReference = new SoftReference<>(test, queue);
        weakReference = new WeakReference<TestObject>(test, queue);
        phantomReference = new PhantomReference<TestObject>(test, queue);

        test = null;// 去除強引用

        new Thread(() -> {
            byte[] bytes = new byte[100 * 1024 * 1024];//觸發(fā)軟引用回收
        }).start();

        try {
            Thread.sleep(1000);
            System.out.println(">> 第一次gc <<");
            System.gc();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

運行結(jié)果

java.lang.ref.SoftReference@71ae1530 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@71ae1530 get null
java.lang.ref.WeakReference@4f6fab91 get null
java.lang.ref.PhantomReference@7f68bd51 get null
java.lang.ref.WeakReference@4f6fab91 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@71ae1530 get null
java.lang.ref.WeakReference@4f6fab91 get null
java.lang.ref.PhantomReference@7f68bd51 get null
== finalize() ==
>> 第一次gc <<
java.lang.ref.PhantomReference@7f68bd51 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@71ae1530 get null
java.lang.ref.WeakReference@4f6fab91 get null
java.lang.ref.PhantomReference@7f68bd51 get null

多執(zhí)行幾次還可能是下面結(jié)果

java.lang.ref.WeakReference@7caf870c 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@adee0ac get null
java.lang.ref.WeakReference@7caf870c get null
java.lang.ref.PhantomReference@7da5a6df get null
java.lang.ref.SoftReference@adee0ac 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@adee0ac get null
java.lang.ref.WeakReference@7caf870c get null
java.lang.ref.PhantomReference@7da5a6df get null
== finalize() ==
>> 第一次gc <<
java.lang.ref.PhantomReference@7da5a6df 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@adee0ac get null
java.lang.ref.WeakReference@7caf870c get null
java.lang.ref.PhantomReference@7da5a6df get null

可以看到內(nèi)存不足的時候把軟引用和弱引用放到隊列，（它們的先后順序未知），然后Finalizer進入隊列，此時TestObject對象逃過了一次GC，同實驗一；然后再執(zhí)行一次GC時PhantomReference進入隊列，這時候?qū)ο蟛疟徽嬲厥铡?/p>

實驗三

實驗二由于申請了大內(nèi)存二導(dǎo)致GC，那么如果沒有內(nèi)存不足，但是存在三個引用會怎么樣呢？我們修改下main方法試試

    public static void main(String[] args) throws Exception {
        TestObject test = new TestObject();
        stopFinalizerThread();
        queue = getFinalizerRefrenceQueue();
        Thread moniterThread = new Thread(new Consumer());
        moniterThread.start();
        softReference = new SoftReference<>(test, queue);
        weakReference = new WeakReference<TestObject>(test, queue);
        phantomReference = new PhantomReference<TestObject>(test, queue);

        test = null;// 去除強引用

        try {
            Thread.sleep(1000);
            System.out.println(">> 第一次gc <<");
            System.gc();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("%s get %s%n", softReference, softReference == null ? null : softReference.get());
        System.out.printf("%s get %s%n", weakReference, weakReference.get());
        System.out.printf("%s get %s%n", phantomReference, phantomReference.get());
    }

得到結(jié)果

>> 第一次gc <<
java.lang.ref.SoftReference@28a418fc get reference.ReferenceTest$TestObject@5305068a
java.lang.ref.WeakReference@1f32e575 get reference.ReferenceTest$TestObject@5305068a
java.lang.ref.PhantomReference@279f2327 get null

實驗四

如果沒有Finalizer會怎么樣呢？我們把實驗二 TestObject 的 finalize方法刪掉

    public static class TestObject {
//        @Override
//        protected void finalize() throws Throwable {
//            System.out.println("== finalize() ==");
//        }
    }

結(jié)果

java.lang.ref.WeakReference@3aa377fc 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@2c7c3cbb get null
java.lang.ref.WeakReference@3aa377fc get null
java.lang.ref.PhantomReference@1d4c9154 get null
java.lang.ref.SoftReference@2c7c3cbb 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@2c7c3cbb get null
java.lang.ref.WeakReference@3aa377fc get null
java.lang.ref.PhantomReference@1d4c9154 get null
java.lang.ref.PhantomReference@1d4c9154 加入引用隊列, ref.get:null
java.lang.ref.SoftReference@2c7c3cbb get null
java.lang.ref.WeakReference@3aa377fc get null
java.lang.ref.PhantomReference@1d4c9154 get null
>> 第一次gc <<

可以看到WeakReference和SoftReference放入隊列后，PhantomReference也進入隊列

結(jié)論

到此基本上對整個過程比較清楚了，可以回答開篇的問題

• SoftReference只有在內(nèi)存不足的時候才會放到隊列，和WeakReference放入隊列的先后順序是隨機的
• 如果有Finalizer，則在SoftReference和WeakReference放入隊列后再放入隊列，這時候強引用還在Finalizer中，執(zhí)行完finalize方法才可能被解除
• finalize執(zhí)行完后，下一次GC才會把PhantomReference放到隊列
• 如果沒有finalize，則軟弱虛都一次性放入隊列，虛引用最后才進入

對于finalize方法和虛引用資源回收的區(qū)別

• finalize方法執(zhí)行時對象引用還在，而虛引用來做資源回收則拿不到包裝的對象
• finalize方法由FinalizerThreaad線程執(zhí)行，線程優(yōu)先級為Thread.MAX_PRIORITY - 2，而且是一個守護線程，而虛引用實現(xiàn)可以自己控制線程
• FinalizerThreaad內(nèi)部是串行處理，而虛引用的實現(xiàn)可以自己做并行處理，總體來說靈活度更高
• finalize降低了gc效率，而虛引用不影響
• 虛引用可以參考Cleaner的實現(xiàn)
• 無論那種方式，其實都不推薦用來關(guān)閉資源，因為虛擬機規(guī)范不保證一定能夠執(zhí)行，所以只能用來補救

疑問

最后還有一點疑問，WeakReference和SoftReference進入隊列先后順序怎么確定？這個比較奇怪，但篇幅有限暫時就不研究了。