【问题标题】：create inner class instance in constructor在构造函数中创建内部类实例
【发布时间】：2016-04-23 15:01:56
【问题描述】：

我正在阅读本书Java concurrency in practice，在第 3.2 节中，它提供了以下代码示例来说明隐式允许 this 引用转义（不要这样做，特别是在构造函数中）：

public class ThisEscape {
    public ThisEscape(EventSource source) {
       source.registerListener ( 
             new EventListener() {
                 public void onEvent(Event e) {
                     doSomething(e);
                 }
             }
       );
  } 
}

这本书接着说：

当ThisEscape 发布EventListener 时，它隐式地也发布封闭的ThisEscape 实例，因为内部类实例包含对封闭实例的隐藏引用。

我从Java的角度理解上面的话，但是我想不出一个例子上面代码的EventListener转义封闭引用this是有害的吗？以什么方式？

例如，如果我创建一个ThisEscape 的新实例：

ThisEscape myEscape = new Escape(mySource);

然后呢？现在危害如何？它在哪些方面有害？

有人可以使用上面的代码作为基础并向我解释它是如何有害的吗？

======= 更多 ======

本书试图表达类似匿名EventListener 的内容，其中包含对尚未完全构造的包含类实例的隐藏引用。我想在例子中知道，这个未完全构造的引用怎么会被滥用，我更喜欢看一个关于这一点的代码示例。

本书给出了正确的做事方式，即使用静态工厂方法，如下所示：

public static SafeListener newInstance(EventSource source) { 
       SafeListener safe = new SafeListener(); 
       source.registerListener (safe.listener);
       return safe;
}

我只是不明白整件事的重点。

【问题讨论】：

感谢您提出这个问题。

标签： java inner-classes

【解决方案1】：

问题1：对非完全构造的对象进行操作

考虑这个稍微修改的例子：

public class ThisEscape {
    private String prefixText = null;

    private void doSomething(Event e) {
        System.out.println(prefixText.toUpperCase() + e.toString());
    }

    public ThisEscape(EventSource source) {
       source.registerListener( 
             new EventListener() {
                 public void onEvent(Event e) {
                     doSomething(e); // hidden reference to `ThisEscape` is used
                 }
             }
       );

       // What if an event is fired at this point from another thread? 
       // prefixText is not yet assigned, 
       // and doSomething() relies on it being not-null

       prefixText = "Received event: ";
    }
}

这会引入一个微妙且非常难以发现的错误，例如在多线程应用程序中。

考虑事件源触发和事件在source.registerListener(...) 完成之后，但在分配prefixText 之前。这可能发生在不同的线程中。

在这种情况下，doSomething() 将访问尚未初始化的prefixText 字段，这将导致NullPointerException。在其他情况下，结果可能是无效的行为或错误的计算结果，这将是比异常更糟糕的事件。而这种错误在实际应用中极难发现，主要是因为it happens sporadically.

问题 2：垃圾回收

在某些情况下，对封闭实例的隐藏引用会阻碍 垃圾收集器 清理“封闭实例”。

如果程序逻辑不再需要封闭实例，但仍然需要它生成的内部类的实例，就会发生这种情况。

如果“封闭实例”又包含对程序逻辑不需要的许多其他对象的引用，那么它将导致大量内存泄漏。

一个代码示例。给定一个稍微修改的ThisEscape 类形式的问题：

public class ThisEscape {

    private long[] aVeryBigArray = new long[4711 * 815];

    public ThisEscape(EventSource source) {
       source.registerListener( 
             new EventListener() {
                 public void onEvent(Event e) {
                     doSomething(e);
                 }
                 private void doSomething(Event e) {
                     System.out.println(e.toString());
                 }
             }
       );
    } 
}

请注意，内部匿名类（扩展/实现EventListener）是非静态的，因此包含对包含类（ThisEscape）实例的隐藏引用。

还要注意匿名类实际上并没有使用这个隐藏的引用：匿名类中没有使用包含类的非静态方法或字段。

现在这可能是一种可能的用法：

// Register an event listener to print the event to System.out
new ThisEscape(myEventSource);

通过这段代码，我们希望在myEventSource 中注册一个事件。我们不再需要ThisEscape 的实例。

但是假设EventSource.registerListener(EventListener)方法存储了对ThisEscape中创建的事件监听器的引用，并且匿名事件监听器持有对包含类实例的隐藏引用，ThisEscape的实例可以'不会被垃圾收集。

我故意将一个大的非静态long 数组放入ThisEscape，以证明ThisEscape 类实例实际上可以保存大量数据（直接或间接），因此内存泄漏可能是重要的。

【讨论】：

谢谢，我明白了。但是本书试图说类似匿名事件侦听器持有对尚未完全构造的包含类实例的隐藏引用，但我想在我的示例中知道，这个未完全构造的引用如何被滥用，我更喜欢查看有关这一点的代码示例。
感谢更新问题；包括使用非完全初始化对象的场景。

【解决方案2】：

在多线程上下文中，在构造过程中发布对象的问题在于，该对象可能在构造完成之前（或在构造函数引发异常之后）使用。

即使发布是构造函数中的最后一个显式步骤，也需要牢记三件事：

线程中副作用的顺序不决定了这些副作用对其他线程可见的顺序。因此，即使构造函数的编写方式是在发布对对象的引用之前完全填充对象，也不能保证其他线程在读取引用时会看到完全填充的对象。
final 字段通常具有特殊的并发属性，但这些属性取决于在对象对其他线程可见之前到达构造函数的末尾。如果其他线程在对象完全构造之前感知到它，那么它们甚至可能看不到final 字段的正确值。
在子类中进行任何初始化之前调用超类构造函数。因此，例如，如果子类包含字段String foo = "foo"，那么在超类构造过程中，该字段仍将是null，这将影响使用它的虚方法的结果。因此，如果在超类构造函数期间发布了对该对象的引用，则其他线程可以在对象处于不完整（和奇怪）状态时对其进行操作。

【讨论】：