堆栈上无法访问的对象无法进行垃圾回收

Question

违背我的期望,以下方案

import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.List;

public class StackTest {
  public static void main(String[] args) {
    Object object1 = new Object();
    Object object2 = new Object();
    List<Object> objects = Arrays.asList(object1, object2);

    WeakReference<Object> ref1 = new WeakReference<>(object1);
    WeakReference<Object> ref2 = new WeakReference<>(object2);

    for (Object o : objects) {
      System.out.println(o);
    }
    objects = null;

    object1 = null;
    object2 = null;

    System.gc();
    System.gc();
    System.gc();

    System.out.println("ref1: " + ref1.get());
    System.out.println("ref2: " + ref2.get());
  }
}

仍打印出来

ref1: java.lang.Object@15db9742
ref2: java.lang.Object@6d06d69c

这意味着object1和object2不GC-ED.

但是,for从程序中删除循环时,可以对这些对象进行GC编辑并打印程序.

ref1: null
ref2: null

将for循环移动到单独的方法具有相同的效果:对象在程序结束时进行GC编辑.

我怀疑发生的是该for循环将这些对象存储在堆栈中,之后不会删除它们.由于对象仍然存在于堆栈中,因此无法进行GC编辑.

看字节代码(我真的不擅长)似乎支持这个假设:

53: invokeinterface #6,  1            // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
58: astore        6
60: aload         6
62: invokeinterface #7,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
67: ifeq          90
70: aload         6
72: invokeinterface #8,  1            // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
77: astore        7
79: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
82: aload         7
84: invokevirtual #10                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
87: goto          60

我看到了astore命令,但我无法在字节代码中找到一个位置,这些位置再次从堆栈中删除.

但是,我的理论有两个问题:

• 根据我对该字节代码的理解,我原本希望将object1其从堆栈中删除(被覆盖object2),并且只有在循环(object2)中访问的最后一个对象才会被GC编辑.

• 将for循环更改为

  for (Object o : objects) {
    System.out.println(o);
    o = null;
  }
  

  不会改变程序的输出.我原以为这会清除对堆栈中对象的引用.

问题:任何人都有一个可靠的理论为什么for-loop确保这些对象不能被GC编辑？我的理论中有一些漏洞.

上下文:在我们用于检测内存泄漏的单元测试中遇到此问题,基于Netbeans方法NBTestCase#assertGC.assertGC当仍在堆或堆栈上引用对象时,此方法将失败.

在我们的测试中,我们有类似的代码

@Test
public void test(){
  List<DisposableFoo> foos = ...;

  doStuffWithFoo(foos);

  List<WeakReference<DisposableFoo>> refs = ...;

  for(DisposableFoo foo : foos){
    disposeFoo(foo);
  }

  foos = null;
  assertGC(refs);
}

在我们删除for-loop 之前,它一直在失败.

我们已经有了一个解决方法(将for-loop 移动到一个单独的方法),但我想了解为什么我们的原始代码不起作用.

Answer 1

问题是您在堆栈上仍然有一个列表迭代器,并且该列表迭代器具有对原始列表的引用.这使得列表保持活着就像你永远不会设置objects为null一样.

迭代器必须保持原来的集合的引用,以便它可以请求下一个项目等.对于经常Iterator<E>它可能潜在地设置其内部参考null一旦hasNext()返回了假的,但对于一个列表迭代器甚至认为并非如此,因为你可以在列表迭代器中向两个方向移动.