java 对象在构造过程中何时变为非空？

Question

假设您正在创建一个 Java 对象，如下所示：

SomeClass someObject = null;
someObject = new SomeClass();

someObject 在什么时候变为非空？ 是在 SomeClass() 构造函数运行之前还是之后？

为了澄清一点，假设另一个线程要在 SomeClass() 构造函数完成一半时检查 someObject 是否为 null，那么它是 null 还是非 null？

另外，如果 someObject 是这样创建的，会有什么区别：

SomeClass someObject = new SomeClass();

someObject 会为空吗？

Answer 1

如果另一个线程要在“构建期间”检查 someObject 变量，我相信它可能会（由于内存模型中的怪癖）看到部分初始化的对象。 新的（从 Java 5 开始）内存模型意味着任何 final 字段都应该在该对象对其他线程可见之前设置为其值（只要对新创建的对象的引用不存在）以任何其他方式从构造函数中逃脱）但除此之外没有太多保证。

基本上，如果没有适当的锁定（或静态初始化器等给出的保证），请勿共享数据:) 说实话，内存模型非常棘手，就像一般的无锁编程一样。 尽量避免这种情况成为可能。

从逻辑术语来看，赋值发生在构造函数运行之后 - 因此，如果您从同一个线程观察变量，则在构造函数调用期间它将为 null 。 然而，正如我所说，内存模型存在一些奇怪之处。

编辑：为了双重检查锁定的目的，如果您的字段是易失性并且如果您使用Java，则您可以摆脱这个 5或更高。 在 Java 5 之前，内存模型对此还不够强大。 不过，您需要完全正确地获得模式。 有关更多详细信息，请参阅《Effective Java》，第 2 版，第 71 项。

编辑：这是我反对亚伦的内联在单个线程中可见的理由。 假设我们有：

public class FooHolder
{
    public static Foo f = null;

    public static void main(String[] args)
    {
        f = new Foo();
        System.out.println(f.fWasNull);
    }
}

// Make this nested if you like, I don't believe it affects the reasoning
public class Foo
{
    public boolean fWasNull;

    public Foo()
    {
        fWasNull = FooHolder.f == null;
    }
}

我相信这将总是报告true。 来自第 15.26.1 节：

否则，需要三个步骤：

• 首先，计算左侧操作数以生成一个变量。 如果本次评估完成
  突然，然后分配
  表达式突然完成
  同样的理由； 右边的操作数是
  未评估且未分配
  发生。
• 否则，将计算右侧操作数。 如果这
  评估突然完成，然后
  赋值表达式完成
  突然出于同样的原因并且没有
  发生分配。

否则，右手的值
操作数转换为类型
左边的变量，受到
到值集转换（§5.1.13）到
适当的标准值设定
（不是扩展指数值集），
转换的结果是
存储到变量中。

然后从 第 17.4.5 节：

两个操作可以按先行发生关系排序。 如果一个操作发生在另一个操作之前，则第一个操作对第二个操作可见并且排序在第二个操作之前。

如果我们有两个动作 x 和 y，我们写 hb(x, y) 来表示 x 发生在 y 之前。

• 如果 x 和 y 是同一线程的操作，并且 x 按程序顺序出现在 y 之前，则为 hb(x, y)。
• 从对象构造函数的末尾到该对象的终结器 (第 12.6 节) 的开头之间存在一个发生前边缘。
• 如果操作 x 与后续操作 y 同步，那么我们也有 hb(x, y)。
• 如果 hb(x, y) 和 hb(y, z)，则 hb(x, z)。

应该注意的是，两个之间存在happens-before关系
行动并不一定意味着它们必须按照该顺序发生
执行。 如果重新排序产生的结果与合法执行一致，
这并不违法。

换句话说，即使在单个线程内发生奇怪的事情也是可以的，但一定不能被观察到。 在这种情况下，差异将是可以观察到的，这就是为什么我认为这是非法的。

Answer 2

someObject 将在构造过程中的某个时刻变为非null。 通常有两种情况：

1. 优化器已内联构造函数
2. 构造函数未内联。

在第一种情况下，VM 将执行以下代码（伪代码）：

someObject = malloc(SomeClass.size);
someObject.field = ...
....

因此在这种情况下，someObject 不是 null 并且 它指向内存这不是 100% 初始化，即并非所有构造函数代码都已运行！ 这就是为什么双重检查锁定不起作用的原因。

在第二种情况下，构造函数中的代码将运行，引用将被传回（就像在普通方法调用中一样），并且 someObject 将被设置为引用的值之后所有和每个初始化代码已运行。

问题是没有办法告诉java不要提前分配someObject。 例如，您可以尝试：

SomeClass tmp = new SomeClass();
someObject = tmp;

但由于未使用 tmp，优化器可以忽略它，因此它将生成与上面相同的代码。

因此，这种行为是为了让优化器生成更快的代码，但在编写多线程代码时它可能会给你带来麻烦。 在单线程代码中，这通常不是问题，因为在构造函数完成之前不会执行任何代码。

[编辑] 这是一篇很好的文章，解释了正在发生的事情： http:// /www.ibm.com/developerworks/java/library/j-dcl.html

PS：书“Effective Java，第二版" 包含适用于 Java 5 及更高版本的解决方案：

private volatile SomeClass field;
public SomeClass getField () {
    SomeClass result = field;
    if (result == null) { // First check, no locking
        synchronized(this) {
            result = field;
            if (result == null) { // second check with locking
                field = result = new SomeClass ();
            }
        }
    }
    return result;
}

看起来很奇怪，但应该适用于每个 Java VM。 请注意，每一点都很重要； 如果省略双重分配，您将获得糟糕的性能或部分初始化的对象。 要获得完整的解释，请购买这本书。

Answer 3

someObject 将是一个空指针，直到从该类型的构造函数为它分配一个指针值为止。 由于赋值是从右到左的，因此另一个线程可能在构造函数仍在运行时检查someObject。 这将发生在将指针分配给变量之前，因此 someObject 仍将为 null。

Answer 4

从另一个线程来看，您的对象仍然看起来为空，直到构造函数完成执行。 这就是为什么如果构造因异常而终止，引用将保持为空。

Object o = null;
try {
    o = new CtorTest();
} catch (Exception e) {
    assert(o == null); // i will be null
}

where

class CtorTest {
    public CtorTest() {
        throw new RuntimeException("Ctor exception.");
    }
}

确保在另一个对象上同步，而不是在正在构造的对象上同步。

Answer 5

对于第一个示例：构造函数完成后，someObject 变为非空。 如果您从另一个线程进行检查，构造函数完成后 someObject 将变为非空。 请注意，您永远不应该从不同的线程访问不同步的对象，因此您的示例不应该在实际代码中以这种方式实现。

对于第二个示例， someObject 永远不会为 null，因为它是在构建 SomeClass 本身并使用新创建的对象创建并初始化 someObject 之后构建的。 对于线程来说也是如此：不要在没有同步的情况下从不同线程访问此变量！

Answer 6

下面是一些测试代码，显示在构造函数完成运行之前该对象为 null：

public class Test {

  private static SlowlyConstructed slowlyConstructed = null;

  public static void main(String[] args) {
    Thread constructor = new Thread() {
      public void run() {
        Test.slowlyConstructed = new SlowlyConstructed();
      }
    };
    Thread checker = new Thread() {
      public void run() {
        for(int i = 0; i < 10; i++) {
          System.out.println(Test.slowlyConstructed);
          try { Thread.sleep(1000); }
          catch(Exception e) {}
        }
      }
    };

    checker.start();
    constructor.start();
  }

  private static class SlowlyConstructed {
    public String s1 = "s1 is unset";
    public String s2 = "s2 is unset";

    public SlowlyConstructed() {
      System.out.println("Slow constructor has started");
      s1 = "s1 is set";
      try { Thread.sleep(5000); }
      catch (Exception e) {}
      s2 = "s2 is set";
      System.out.println("Slow constructor has finished");
    }

    public String toString() {
      return s1 + ", " + s2;
    }
  }
}

输出：

null
Slow constructor has started
null
null
null
null
null
Slow constructor has finished
s1 is set, s2 is set
s1 is set, s2 is set
s1 is set, s2 is set
s1 is set, s2 is set