对“this”有一个 PhantomReference 是否安全？

Question

我有一个共享资源，我想知道有多少其他对象仍在使用该资源。为此，我想使用PhantomReferences。

由于ReferenceQueues 不跟踪为它们注册的引用（source，“通知”部分），我的想法是将引用存储为被跟踪对象的字段：

class Foo {
    private PhantomReference<Foo> thisReference;

    public Foo(ReferenceQueue<Foo> queue) {
        thisReference = new PhantomReference<>(this, queue);
    }
}

这是否安全，基于 PhantomReferences 的 Java 9(+) 行为，或者是否有可能在没有将引用添加到队列的情况下对实例进行垃圾收集？

文档说：

假设垃圾收集器在某个时间点确定一个对象是幻影可达的。那时它将自动清除对该对象的所有幻像引用以及对该对象可从中访问的任何其他幻像可访问对象的所有幻像引用。在同一时间或稍后的某个时间，它会将那些在引用队列中注册的新清除的幻像引用排入队列。

但它没有提到垃圾收集是否可以在引用入队之前发生。

Answer 1

package documentation 包含误导性短语：“一个对象幻象可达，如果它既不是强、软或弱可达的，它已经被最终确定，并且一些幻象引用引用它。 ”

“一些幻像引用”并没有强调引用对象本身必须是可访问的这一事实，这在 通知 部分中有说明：

已注册的引用对象与其队列之间的关系是片面的。也就是说，队列不会跟踪向其注册的引用。如果已注册的引用本身变得不可访问，则它永远不会被加入队列。

由于幻象可达没有任何实际后果，除了可能导致幻象引用排队之外，这才是最重要的。

请注意，软可达性和弱可达性的定义更好：

• 如果一个对象不是强可达但可以通过遍历软引用到达，那么它是软可达。
• 一个对象弱可达，如果它既不是强可达也不是软可达，但可以通过遍历弱引用来达到。 …

这里强调的是对象必须是通过引用对象可达的，这意味着引用对象也必须是可达的。

以类似方式定义幻象可达性的问题在于，幻象可达性对象实际上是不可达的，因为PhantomReference 覆盖get() 方法总是返回null，因此应用程序无法访问所指对象因此，不会遍历任何幻像可达对象。

也许，一个更好的定义应该是

• 一个对象是幻影可达，如果它既不是强、软或弱可达的，它已经被终结，但可以通过遍历一个垃圾收集器到达幻影参考。

使用该定义，很明显，您的带有自引用的示例将不起作用，就像它不适用于 WeakReference 或 SoftReference。请注意，当您的类没有专用的 finalize() 方法时，使用 WeakReference 或 PhantomReference 之间没有实际区别。

似乎即使是 API 设计者也没有完全理解其中的含义，因为 specification prior to Java 9 包含规则：

与软引用和弱引用不同，幻像引用在排队时不会被垃圾收集器自动清除。可以通过幻像引用访问的对象将保持不变，直到所有此类引用都被清除或自身变得不可访问。

它公然忽略了幻像可达对象不可访问的点，至少从应用程序的角度来看，并从垃圾收集器的角度保持它幻像可达没有实际的好处。不让对象再次活跃，是最终确定的最大区别。但请注意，在这个地方，文档承认如果幻像引用本身变得不可访问，则引用对象将停止幻像可访问。

从 Java 9 开始，幻像引用在入队时会自动清除，因此对象从 幻像可达 到 不可达 的转换的唯一实际含义是幻像引用被排队。这要求引用对象是可访问的。

Answer 2

我认为你正在做的事情不会奏效。

对象幻象可达的先决条件是：

• 对象不是强可达、软可达或弱可达，
• 对象已经完成，并且
• 该对象可以从 GC 根通过至少一个带有幻像引用的路径访问。

在您的情况下，前两个先决条件得到满足，但第三个不满足。如果我们假设this 不可访问，这意味着this.thisReference 也不可访问。这意味着 Foo 实例的 PhantomReference 将没有资格入队。

（但是，它是“安全的”，因为它不会引发异常或使 JVM 崩溃，或有任何其他不良副作用。）

Answer 3

不，存储对this 的引用将不起作用：

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceTest {
    private final PhantomReference<Object> thisReference;

    public PhantomReferenceTest(ReferenceQueue<Object> queue) {
        thisReference = new PhantomReference<>(this, queue);
    }

    public static void main(String[] args) throws InterruptedException {
        test(false);
        System.out.println("\nVerify that reference is enqueued if gc of thisReference is prevented:");
        test(true);
    }

    private static void test(boolean keepRefToRef) throws InterruptedException {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        ReferenceQueue<Object> verifyQueue = new ReferenceQueue<>();

        PhantomReference<?> refToRef = null;
        PhantomReferenceTest obj = new PhantomReferenceTest(queue);
        PhantomReference<?> verifyReference = new PhantomReference<>(obj, verifyQueue);

        if (keepRefToRef) {
            // Verify that reference is enqueued if it is kept alive
            refToRef = obj.thisReference;
        }

        obj = null;

        System.gc();
        verifyQueue.remove();
        System.out.println("Object was collected");
        System.out.println("thisReference was enqueued: " + (queue.poll() != null));

        // Pretend to use refToRef to make sure gc cannot collect it
        if (refToRef != null) {
            refToRef.get();
        }
    }
}

即使它会起作用，似乎也不能保证它在未来也会继续起作用。甚至不能保证一个字段在封闭类之后被认为是虚拟可达的。在 Java 12.0.1 中则相反：

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class EnqueuingOrder {
    private static class RefToField extends PhantomReference<Object> {
        public RefToField(Object obj, ReferenceQueue<Object> queue) {
            super(obj, queue);
        }
    }

    private final Object field;

    public EnqueuingOrder() {
        field = new Object();
    }

    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();

        EnqueuingOrder obj = new EnqueuingOrder();
        PhantomReference<?> refToObj = new PhantomReference<>(obj, queue);
        PhantomReference<?> refToField = new RefToField(obj.field, queue);
        obj = null;

        System.gc();

        System.out.println("First: " + queue.remove());
        System.out.println("Second: " + queue.remove());
    }
}