Java中的构造函数同步

Question

有人告诉我Java构造函数是同步的，因此在构造过程中不能同时访问它，我想知道：如果我有一个将对象存储在映射中的构造函数，并且另一个线程从该映射中检索它在它的构造完成之前，该线程会阻塞直到构造函数完成吗？

让我用一些代码来演示一下：

public class Test {
    private static final Map<Integer, Test> testsById =
            Collections.synchronizedMap(new HashMap<>());
    private static final AtomicInteger atomicIdGenerator = new AtomicInteger();
    private final int id;

    public Test() {
        this.id = atomicIdGenerator.getAndIncrement();
        testsById.put(this.id, this);
        // Some lengthy operation to fully initialize this object
    }

    public static Test getTestById(int id) {
        return testsById.get(id);
    }
}

假设 put/get 是地图上唯一的操作，所以我不会通过迭代之类的方式获得 CME，并尝试忽略此处的其他明显缺陷。

我想知道的是，如果另一个线程（显然不是构造对象的线程）尝试使用getTestById 访问对象并在其上调用某些东西，它会阻塞吗？换句话说：

Test test = getTestById(someId);
test.doSomething(); // Does this line block until the constructor is done?

我只是想澄清一下构造函数同步在 Java 中的进展情况，以及这样的代码是否会出现问题。我最近看到了这样的代码，而不是使用静态工厂方法，我想知道这在多线程系统中有多危险（或安全）。

Answer 1

有人告诉我，Java 构造函数是同步的，因此在构造过程中不能同时访问它

当然不是这样。与构造函数没有隐含的同步。不仅可以同时发生多个构造函数，而且还可以通过例如在构造函数内部分叉一个线程来引用正在构造的 this 来解决并发问题。

如果我有一个将对象存储在映射中的构造函数，并且另一个线程在其构造完成之前从该映射中检索它，那么该线程会阻塞直到构造函数完成吗？

不会的。

线程应用程序中构造函数的最大问题是编译器有权在 Java 内存模型下对构造函数内部的操作重新排序，以便它们发生在之后（所有事情中）创建对象引用并完成构造函数。 final 字段将保证在构造函数完成时完全初始化，但不会保证其他“正常”字段。

在您的情况下，由于您将 Test 放入同步映射中，并且 然后 继续进行初始化，正如 @Tim 所提到的，这将允许其他线程获取对象可能处于半初始化状态。一种解决方案是使用static 方法来创建您的对象：

private Test() {
    this.id = atomicIdGenerator.getAndIncrement();
    // Some lengthy operation to fully initialize this object
}

public static Test createTest() {
    Test test = new Test();
    // this put to a synchronized map forces a happens-before of Test constructor
    testsById.put(test.id, test);
    return test;
}

我的示例代码有效，因为您正在处理一个同步映射，它调用 synchronized 以确保 Test 构造函数已完成并已实现内存同步。

您的示例中的大问题是“发生之前”保证（构造函数可能在将Test 放入映射之前无法完成）和内存同步（构造线程和获取线程可能会看到不同的内存对于Test 实例）。如果将put 移到构造函数之外，则两者都由同步映射处理。 synchronized 在什么对象上都没有关系，以保证构造函数在放入映射之前已经完成并且内存已经同步。

我相信，如果您在构造函数的 very 末尾调用 testsById.put(this.id, this);，实际上您可能会没事，但这不是好的形式，至少需要仔细的注释/文档。如果类是子类并且在super() 之后的子类中进行了初始化，这不会解决问题。我展示的static 解决方案是一个更好的模式。

Answer 2

你被误导了。您所描述的实际上被称为不当发布，并在 Java Concurrency In Practice 一书中进行了详细讨论。

所以是的，另一个线程有可能获得对您的对象的引用并在它完成初始化之前开始尝试使用它。但是等等，考虑这个答案会变得更糟：https://stackoverflow.com/a/2624784/122207 ...基本上可以对引用分配和构造函数完成进行重新排序。在引用的示例中，一个线程可以在新实例上分配h = new Holder(i)，另一个线程调用h.assertSanity()，时机恰到好处，以便为Holder 的构造函数中分配的n 成员获取两个不同的值。

Answer 3

这是不安全的。 JVM 中没有额外的同步。你可以这样做：

public class Test {
    private final Object lock = new Object();
    public Test() {
        synchronized (lock) {
            // your improper object reference publication
            // long initialization
        }
    }

    public void doSomething() {
        synchronized (lock) {
            // do something
        }
    }
}

Answer 4

构造函数和其他方法一样，没有额外的同步（除了处理final字段）。

如果this 稍后发布，代码将起作用

public Test() 
{
    // Some lengthy operation to fully initialize this object

    this.id = atomicIdGenerator.getAndIncrement();
    testsById.put(this.id, this);
}

Answer 5

有人告诉我 Java 构造函数是同步的

“某个地方的某个人”被严重误导。构造函数不同步。证明：

public class A
{
    public A() throws InterruptedException
    {
        wait();
    }

    public static void main(String[] args) throws Exception
    {
        A a = new A();
    }
}

此代码在wait() 调用中抛出java.lang.IllegalMonitorStateException。如果同步有效，则不会。

这甚至没有意义。它们不需要同步。只能在new(), 之后调用构造函数，并且根据定义，new() 的每次调用都返回不同的值。因此，构造函数被两个线程同时调用且具有相同this 值的可能性为零。所以不需要构造函数的同步。

如果我有一个将对象存储在映射中的构造函数，并且另一个线程在其构造完成之前从该映射中检索它，那么该线程会阻塞直到构造函数完成吗？

没有。为什么会这样做？谁来阻止它？让 'this' 从这样的构造函数中逃逸是不好的做法：它允许其他线程访问仍在构造中的对象。

Answer 6

虽然这个问题得到了回答，但是粘贴的代码没有遵循安全的构造技术，因为它允许这个引用从构造函数中逃逸，我想分享一个由 Brian Goetz 提供的漂亮解释在article: "Java theory and practice: Safe construction techniques" at the IBM developerWorks website。