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

背景

最近读了寒泉子关于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: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<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: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<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进入队列先后顺序怎么确定？这个比较奇怪，但篇幅有限暂时就不研究了。

最后编辑于：2020.09.16 09:34:04

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,658评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,482评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 160,213评论 0赞 350
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,395评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,487评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,523评论 1赞 293
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,525评论 3赞 414
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,300评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,753评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,048评论 2赞 330
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,223评论 1赞 343
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,905评论 5赞 338
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,541评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,168评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,417评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,094评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,088评论 2赞 352

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

背景

原理回顾

实验思路

实验一

实验二

实验三

实验四

结论

疑问

推荐阅读更多精彩内容