Question

我正在使用一些代码，其中一个对象“foo”正在创建另一个对象对象，“bar”，并传递Callable。在此之后foo将返回吧，然后我希望foo变得无法访问（即：可用于垃圾收集）。

我最初的想法是匿名创建Callable。例如：

class Foo {
  ...

  public Bar createBar() {
    final int arg1 = ...
    final int arg2 = ...
    final int arg3 = ...
    return new Callable<Baz>() {
      @Override
      public Baz call() {
        return new Baz(arg1, arg2, arg3);
      }
    };
  }
}

在我看来，这可能实际上并没有按预期工作，但是，作为内部类通常保持对其封闭对象的引用。我不想在这里引用封闭类，因为我想要封闭对象在Callable仍然可以访问时收集。

另一方面，检测到实际上从未引用封闭实例应该是非常简单的，所以也许Java编译器足够聪明在这种情况下不包括参考文献。

所以......一个匿名内部类的实例会持有一个引用它的封闭实例，即使它实际上从未使用过封闭实例引用？

Answer 1

是的，匿名内部类的实例持有a 引用它们的封闭实例，即使这些引用是从未实际使用过。这段代码：

public class Outer {
  public Runnable getRunnable() {
    return new Runnable() {
      public void run() {
        System.out.println("hello");
      }
    };
  }
}

使用javac编译时会生成两个类文件Outer.class和。{1}} Outer$1.class。拆解后者，匿名的内部阶级， javap -c收益率：

Compiled from "Outer.java"
class Outer$1 extends java.lang.Object implements java.lang.Runnable{
final Outer this$0;

Outer$1(Outer);
  Code:
   0:   aload_0
   1:   aload_1
   2:   putfield        #1; //Field this$0:LOuter;
   5:   aload_0
   6:   invokespecial   #2; //Method java/lang/Object."<init>":()V
   9:   return

public void run();
  Code:
   0:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   ldc     #4; //String hello
   5:   invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:   return

}

putfield行显示对封闭实例的引用由构造函数存储在字段this$0（类型Outer）中即使这个领域从未再次使用过。

如果你试图创造小的潜力，这是不幸的具有匿名内部类的长寿命对象，因为它们将保留在（可能很大）封闭实例。解决方法是使用静态类（或顶级类）的实例。不幸的是，这更加冗长。

Answer 2

通过在类中引入静态方法，您可以轻松地将嵌套的匿名类转换为“静态”匿名类。

import java.util.ArrayList;


public class TestGC {
    public char[] mem = new char[5000000];
    public String str = "toto";

    public interface Node {
        public void print();
    }

    public Node createNestedNode() {
        final String str = this.str;
        return new Node() {
            public void print() {
                System.out.println(str);
            }
        };
    }

    public static Node createStaticNode(TestGC test) {
        final String str = test.str;
        return new Node() {
            public void print() {
                System.out.println(str);
            }
        };
    }

    public Node createStaticNode() {
        return createStaticNode(this);
    }

    public static void main(String... args) throws InterruptedException {
        ArrayList<Node> nodes = new ArrayList<Node>();
        for (int i=0; i<10; i++) {
            // Try once with createNestedNode(), then createStaticNode()
            nodes.add(new TestGC().createStaticNode());
            System.gc();
            //Thread.sleep(200);
            System.out.printf("Total mem: %d  Free mem: %d\n", Runtime.getRuntime().totalMemory(), Runtime.getRuntime().freeMemory());
        }
        for (Node node : nodes)
            node.print();
        nodes = null;
        System.gc();
        //Thread.sleep(200);
        System.out.printf("Total mem: %d  Free mem: %d\n", Runtime.getRuntime().totalMemory(), Runtime.getRuntime().freeMemory());
    }
}

Answer 3

静态替代（在这种情况下）不是更大（1行）：

public class Outer {
  static class InnerRunnable implements Runnable {
      public void run() {
        System.out.println("hello");
      }
    }
  public Runnable getRunnable() {
    return new InnerRunnable();
  }
}

BTW：如果在Java8中使用Lambda，则不会生成嵌套类。但是我不确定在这种情况下传递的CallSite对象是否包含对外部实例的引用（如果不需要）。

匿名类总是保持对其封闭实例的引用吗？

3 个答案:

匿名类*总是*保持对其封闭实例的引用吗？

3 个答案:

匿名类总是保持对其封闭实例的引用吗？