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

左手java右手go

发布于 2019-08-20 15:55:32

8660

发布于 2019-08-20 15:55:32

文章被收录于专栏：左手java右手go左手java右手go

背景

最近读了寒泉子关于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<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() ==");
       }
   }
 ...
}

结果

>> 第一次gc <<
java.lang.ref.WeakReference@262caf93 加入引用队列, ref.get:nullnull get nulljava.lang.ref.WeakReference@262caf93 get nulljava.lang.ref.PhantomReference@31fa332f get null== finalize() ==>> 第二次gc <<
java.lang.ref.PhantomReference@31fa332f 加入引用队列, ref.get:nullnull get nulljava.lang.ref.WeakReference@262caf93 get nulljava.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<TestObject>(test, queue);
       phantomReference = new PhantomReference<TestObject>(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:nulljava.lang.ref.SoftReference@adee0ac get nulljava.lang.ref.WeakReference@7caf870c get nulljava.lang.ref.PhantomReference@7da5a6df get nulljava.lang.ref.SoftReference@adee0ac 加入引用队列, ref.get:nulljava.lang.ref.SoftReference@adee0ac get nulljava.lang.ref.WeakReference@7caf870c get nulljava.lang.ref.PhantomReference@7da5a6df get null== finalize() ==
>> 第一次gc <<
java.lang.ref.PhantomReference@7da5a6df 加入引用队列, ref.get:nulljava.lang.ref.SoftReference@adee0ac get nulljava.lang.ref.WeakReference@7caf870c get nulljava.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<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());
   }

得到结果

>> 第一次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进入队列先后顺序怎么确定？这个比较奇怪，但篇幅有限暂时就不研究了。

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2019-02-09，如有侵权请联系 cloudcommunity@tencent.com 删除

java

编程算法

本文分享自左手java右手go 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

java

编程算法

登录后参与评论

0 条评论

热度