虚引用和终结器引用

最新推荐文章于 2026-02-07 20:47:22 发布

原创最新推荐文章于 2026-02-07 20:47:22 发布 · 560 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#JVM

JVM 专栏收录该内容

282 篇文章

订阅专栏

一虚引用

也称为“幽灵引用”或者“幻影引用”，是所有引用类型中最弱的一个。

一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。

它不能单独使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的 get() 方法取得对象时，总是 null。

为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如：能在这个对象被收集器回收时收到一个系统通知。

虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入引用队列，以通知应用程序对象的回收情况。

由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。

虚引用无法获取到我们的数据

在 JDK1.2 版之后提供了 PhantomReference 类来实现虚引用。

// 声明强引用

Object obj = new Object();

// 声明引用队列

ReferenceQueue phantomQueue = new ReferenceQueue();

// 声明虚引用（还需要传入引用队列）

PhantomReference<Object> sf = new PhantomReference<>(obj, phantomQueue);

obj = null;

二实战——跟踪对象

1 目的

结合虚引用，引用队列，finalize 来看虚引用。

2 代码

/**
* 虚引用的测试——跟踪对象
*/
public class PhantomReferenceTest {
    public static PhantomReferenceTest obj; // 当前类对象的声明
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null; // 引用队列

    public static class CheckRefQueue extends Thread {
        @Override
        public void run() {
            while (true) {
                if (phantomQueue != null) {
                    PhantomReference<PhantomReferenceTest> objt = null;
                    try {
                        objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (objt != null) {
                        System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");
                    }
                }
            }
        }
    }

    @Override
    protected void finalize() throws Throwable { //finalize()方法只能被调用一次！
        super.finalize();
        System.out.println("调用当前类的finalize()方法");
        obj = this;
    }

    public static void main(String[] args) {
        Thread t = new CheckRefQueue();
        t.setDaemon(true); // 设置为守护线程：当程序中没有非守护线程时，守护线程也就执行结束。
        t.start();


        phantomQueue = new ReferenceQueue<PhantomReferenceTest>();
        obj = new PhantomReferenceTest();
        // 构造了 PhantomReferenceTest 对象的虚引用，并指定了引用队列
        PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<PhantomReferenceTest>(obj, phantomQueue);
        try {
            // 不可获取虚引用中的对象
            System.out.println(phantomRef.get());

            // 将强引用去除
            obj = null;
            // 第一次进行GC,由于对象可复活，GC无法回收该对象
            System.gc();
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
            System.out.println("第 2 次 gc");
            obj = null;
            System.gc(); // 一旦将obj对象回收，就会将此虚引用存放到引用队列中。
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3 运行结果

null

第一次GC操作

调用当前类的finalize方法

obj 不是 null

第二次GC操作

追踪垃圾回收过程：PhantomReferenceTest实例被GC了

obj 是 null

4 说明

从上述运行结果我们知道，第一次尝试获取虚引用的值，发现无法获取的，这是因为虚引用是无法直接获取对象的值，然后进行第一次 gc ，因为会调用 finalize 方法，将对象复活了，所以对象没有被回收，但是调用第二次 gc 操作的时候，因为 finalize 方法只能执行一次，所以就触发了 GC 操作，将对象回收了，同时将会触发第二个操作就是将虚引用对象存入到引用队列中。