垃圾回收机制中的非直观对象驱逐

Question

我正在调试内存泄漏，不得不深入CompletableFuture内部。有这样一段代码(completablefuture . unicomposestage):

CompletableFuture<V> g = f.apply(t).toCompletableFuture();
...
CompletableFuture<V> d = new CompletableFuture<V>();
UniRelay<V> copy = new UniRelay<V>(d, g);
g.push(copy);
copy.tryFire(SYNC);
return d;

代码本身对我来说很清楚：应用一个返回完成阶段（g）的函数，创建一个中继，最终将值转移到另一个可完成的未来（d），然后返回另一个未来（d）。我看到以下参考情况：

• 复制同时引用d和g（并且构造函数中没有魔法，只有字段分配）
• g引用复制
• d没有引用任何内容

只有d被返回，所以，事实上，g和Copy对我来说都是内部方法变量，（乍一看）永远不应该离开方法并最终被gc。天真的测试和它是由久经考验的开发人员很久以前编写的事实都表明我错了，错过了一些东西。是什么原因使这些对象从垃圾回收机制中被省略？

Answer 1

在引用的代码中，没有什么可以阻止这些期货的垃圾回收，也没有必要。有问题的代码适用于以下情况：第一个可完成未来（此实例）已完成，而直接计算的撰写函数返回的可完成未来尚未完成。

现在，有两种可能的情况

>

正在进行完成尝试。然后，最终完成未来的代码将保留对它的引用，当完成时，它将触发相关阶段的完成（通过g.push（copy）注册）。在这种情况下，依赖阶段不需要保存对其先决阶段的引用。

这是一种一般模式。如果有一个链 x --将完成→ y，则不会有从 y 到 x 的引用。

没有对< code>CompletableFuture实例< code>g的其他引用，且< code>g尚未完成。在这种情况下，它将永远不会完成，在内部持有对< code>g的引用也不会改变这一点。那只会浪费资源。

以下示例程序将对此进行说明：

public static void main(String[] args) throws Throwable {
    ReferenceQueue<Object> discovered = new ReferenceQueue<>();
    Set<WeakReference<?>> holder = new HashSet<>();

    CompletableFuture<Object> initial = CompletableFuture.completedFuture("somevalue");

    CompletableFuture<Object> finalStage = initial.thenCompose(value -> {
        CompletableFuture<Object> lost = new CompletableFuture<>();
        holder.add(new WeakReference<>(lost, discovered));
        return lost;
    });
    waitFor(finalStage, holder, discovered);
    finalStage = initial.thenCompose(value -> {
        CompletableFuture<Object> saved = CompletableFuture.supplyAsync(()-> {
            LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
            return "newvalue";
        });
        holder.add(new WeakReference<>(saved, discovered));
        return saved;
    });
    waitFor(finalStage, holder, discovered);
}
private static void waitFor(CompletableFuture<Object> f, Set<WeakReference<?>> holder,
                    ReferenceQueue<Object> discovered) throws InterruptedException {
    while(!f.isDone() && !holder.isEmpty()) {
        System.gc();
        Reference<?> removed = discovered.remove(100);
        if(removed != null) {
            holder.remove(removed);
            System.out.println("future has been garbage collected");
        }
    }
    if(f.isDone()) {
        System.out.println("stage completed with "+f.join());
        holder.clear();
    }
}

传递给thenCompose的第一个函数创建并返回一个新的未完成的CompletableFuture，而不尝试完成它，也不保存或存储对它的任何其他引用。相反，第二个函数通过Supply yAsync创建CompletableFuture，提供一个供应商，它将在一秒钟后返回一个值。

在我的系统上，它一直在打印

future has been garbage collected
stage completed with newvalue

表明废弃的未来不会被阻止垃圾收集，而另一个将至少保留到完成。