匿名类*总是*维护对其封闭实例的引用吗?

问题描述

我正在处理一些代码，其中一个对象foo"正在创建另一个对象，bar"，并传递给它一个 Callable.在此 foo 将返回之后bar，然后我希望 foo 变得无法访问(即:可用于垃圾收集).

I'm working with some code where one object, "foo", is creating another object, "bar", and passing it a Callable. After this foo will return bar, and then I want foo to become unreachable (ie: available for garbage collection).

我最初的想法是匿名创建 Callable.例如:

My initial thought was to just create the Callable anonymously. eg:

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 仍可访问时收集.

It occurred to me that this might not actually work as desired, however, as an inner class typically keeps a reference to its enclosing object. I don't want a reference to the enclosing class here, because I want the enclosing object to be collected while the Callable is still reachable.

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

On the other hand, detecting that the enclosing instance is never actually referred to should be pretty trivial, so perhaps the Java compiler is smart enough to not include a reference in that case.

所以...匿名内部类的实例是否会保留一个引用其封闭实例，即使它从未实际使用附上实例引用?

So... will an instance of an anonymous inner class hold on to a reference to its enclosing instance even if it never actually uses the enclosing instance reference?

推荐答案

是的，匿名内部类的实例保持一个引用它们的封闭实例，即使这些引用是从未实际使用过.这段代码:

Yes, instances of anonymous inner classes hold on to a reference to their enclosing instances even if these references are never actually used. This code:

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

使用 javac 编译时会生成两个类文件，Outer.class 和Outer$1.class.拆解后者，匿名内部类，使用 javap -c 产生:

When compiled with javac generates two class files, Outer.class and Outer$1.class. Disassembling the latter, the anonymous inner class, with javap -c yields:

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)中即使此字段不再使用.

The putfield line shows that a reference to the enclosing instance is being stored in the field this$0 (of type Outer) by the constructor even though this field is never used again.

如果您试图创建小的潜在具有匿名内部类的长寿命对象，因为它们将保留(可能很大)封闭实例.一种解决方法是改用静态类(或顶级类)的实例.不幸的是，这更冗长.

This is unfortunate if you're attempting to create small potentially long-lived objects with anonymous inner classes as they'll hold onto the (potentially large) enclosing instance. A workaround is to use an instance of a static class (or a top-level class) instead. This is unfortunately more verbose.

这篇关于匿名类*总是*维护对其封闭实例的引用吗?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，WP2