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编辑的。

但是，从程序中删除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覆盖），并且只在循环中访问最后一个对象（{{1 }}）不会被GC编辑。
将object2循环更改为
```
for
```
不会更改程序的输出。我原以为这会清除对堆栈中对象的引用。

问题：任何人都有一个关于为什么for (Object o : objects) { System.out.println(o); o = null; } - 循环确保这些对象无法进行GC编辑的可靠理论？我的理论中有一些漏洞。

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

在我们的测试中，我们有像

这样的代码

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 - 循环移动到一个单独的方法），但我想了解为什么我们的原始代码不起作用。

Answer 1

问题是你在堆栈上仍然有一个列表迭代器，并且该列表迭代器具有对原始列表的引用。这样就可以保持列表的活着，就好像你从未将objects设置为null一样。

迭代器必须保留对原始集合的引用，以便它可以请求 next 项目等。对于常规Iterator<E>，它可能可能一旦null返回false，就将其内部引用设置为hasNext()，但对于列表迭代器，即使不是这样，因为您可以在列表迭代器中向两个方向移动。

Answer 2

更改for循环，然后重试

for (int i = 0; i < objects.size(); i++)
{
    Object o = objects.get(i);
    System.out.println(o);
}

Answer 3

除了使用传统循环之外，您可以wrap for-loop { for (Object o : objects) { System.out.println(o); } }以使其超出范围并被收集

IndexedDB

生成的迭代器内容在超出范围之前不会被清除

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

3 个答案: