背景

最近读了寒泉子关于Finalizer的分享 JVM源码分析之FinalReference完全解读 - InfoQ
结合之前对java引用类型的了解，突然想到几个开脑洞的问题：

如果一个对象没有强引用，但是同时有软引用和弱引用，或者同时有弱引用和虚引用，甚至三者同时出现，会发生什么？
finalize方法和虚引用都可以作为资源回收的最后最后防线，那么它们的区别是什么？它们同时存在会怎么样？

原理回顾

强引用（StrongReference）：就是我们平时用的等号赋值
软引用（SoftReference）：当对象只有软引用，内存不足时可以被回收，同时可以把Reference对象塞入ReferenceQueue
弱引用：当对象只有弱引用，发生GC时可以被回收，同时可以把Reference对象塞入ReferenceQueue
虚引用（WeakReference）：相当于没有引用，get方法一直返回null，发生GC时可以被回收，同时可以把Reference对象塞入ReferenceQueue
FinalizerReference：实现finalize方法的对象执行完构造方法都会被FinalizerReference包装，并加入到 Finalizer 的静态链表中，当发生GC时，refrence被塞进ReferenceQueue队列，由FinalizerThread线程取出，将reference从静态链表解除，并执行对象的finalize方法（注意：此时对象引用还在，所以逃过一次GC）

实验思路

我们是想验证各个引用类型进入队列的顺序，所以需要绑定到同一个ReferenceQueue，实现方式是利用反射把Finalizer里面的queue静态属性拿出来

    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掉，我们自己实现一个线程串行来消费队列里的元素

    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线程执行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();
                }
            }
        }
    }

实验一

由于软引用比较难触发，所以实验一先排除它。我们写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 softReference = null;
    static WeakReference weakReference = null;
    static PhantomReference 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(test, queue);
        phantomReference = new PhantomReference(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() ==");
        }
    }
  ...
}

结果

>> 第一次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静态链条上解除）；第二次GC后PhantomReference进入队列；并且第一次GC后WeakReference和PhantomReference就get不到对象了

实验二

为了触发软引用，我们需要申请一块大内存，看下面改造后的main方法，再加上 -Xmx128m -Xms128m -Xmn28m 启动参数

    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(test, queue);
        phantomReference = new PhantomReference(test, queue);

        test = null;// 去除强引用

        new Thread(() -> {
            byte[] bytes = new byte[100 * 1024 * 1024];//触发软引用回收
        }).start();

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

运行结果

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

多执行几次还可能是下面结果

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

可以看到内存不足的时候把软引用和弱引用放到队列，（它们的先后顺序未知），然后Finalizer进入队列，此时TestObject对象逃过了一次GC，同实验一；然后再执行一次GC时PhantomReference进入队列，这时候对象才被真正回收。

实验三

实验二由于申请了大内存二导致GC，那么如果没有内存不足，但是存在三个引用会怎么样呢？我们修改下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(test, queue);
        phantomReference = new PhantomReference(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());
    }

得到结果

>> 第一次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() ==");
//        }
    }

结果

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也进入队列

结论

到此基本上对整个过程比较清楚了，可以回答开篇的问题

SoftReference只有在内存不足的时候才会放到队列，和WeakReference放入队列的先后顺序是随机的
如果有Finalizer，则在SoftReference和WeakReference放入队列后再放入队列，这时候强引用还在Finalizer中，执行完finalize方法才可能被解除
finalize执行完后，下一次GC才会把PhantomReference放到队列
如果没有finalize，则软弱虚都一次性放入队列，虚引用最后才进入

对于finalize方法和虚引用资源回收的区别

finalize方法执行时对象引用还在，而虚引用来做资源回收则拿不到包装的对象
finalize方法由FinalizerThreaad线程执行，线程优先级为Thread.MAX_PRIORITY - 2，而且是一个守护线程，而虚引用实现可以自己控制线程
FinalizerThreaad内部是串行处理，而虚引用的实现可以自己做并行处理，总体来说灵活度更高
finalize降低了gc效率，而虚引用不影响
虚引用可以参考Cleaner的实现
无论那种方式，其实都不推荐用来关闭资源，因为虚拟机规范不保证一定能够执行，所以只能用来补救

疑问

最后还有一点疑问，WeakReference和SoftReference进入队列先后顺序怎么确定？这个比较奇怪，但篇幅有限暂时就不研究了。

关于Reference与finalize的一点思考和研究

背景

原理回顾

实验思路

实验一

实验二

实验三

实验四

结论

疑问

你可能感兴趣的:(关于Reference与finalize的一点思考和研究)