为什么 Java 构造函数不能同步？

Question

根据the Java Language Specification，构造函数不能标记为同步，因为在创建它的线程完成之前，其他线程无法看到正在创建的对象。这似乎有点奇怪，因为我确实可以让另一个线程在构建对象时查看它：

public class Test {
    public Test() {
       final Test me = this;
       new Thread() {
           @Override
           public void run() {
               // ... Reference 'me,' the object being constructed
           }
       }.start();
    }
}

我知道这是一个非常人为的例子，但理论上似乎有人可以提出一个更现实的情况，将构造函数标记为同步是合法的，以防止像这样的线程竞争。

我的问题是：Java 是否有理由明确禁止构造函数上的同步修饰符？也许我上面的例子有缺陷，或者真的没有理由，这是一个任意的设计决定。无论哪种情况，我都很好奇，很想知道答案。

Answer 1

因为synchronized 保证对同一对象的操作不会由多个线程执行。当构造函数被调用时，你仍然没有对象。两个线程访问同一个对象的构造函数在逻辑上是不可能的。

在您的示例中，即使新线程调用了一个方法，它也不再与构造函数有关 - 它与目标方法是否同步有关。

Answer 2

在您的示例中，构造函数实际上只从一个线程调用一次。

是的，可以获得对不完全构造的对象的引用（一些关于双重​​检查锁定的讨论以及它被破坏的原因揭示了这个问题），但是，不能通过第二次调用构造函数。

在构造函数上同步会阻止两个线程同时在同一个对象上调用构造函数，这是不可能的，因为永远不可能两次在对象实例上调用构造函数。

Answer 3

如果您确实需要将构造函数的其余部分与任何获取到您尚未完全构造的对象的引用的线程同步，您可以使用同步块：

public class Test {
    public Test() {
       final Test me = this;
       synchronized(this) {
          new Thread() {
             @Override
             public void run() {
                // ... Reference 'me,' the object being constructed
                synchronized(me) {
                   // do something dangerous with 'me'.
                }
             }
          }.start();
          // do something dangerous with this
       }
    }
}

通常，像这样“放弃”尚未构造的对象被认为是不好的风格，因此不需要同步构造函数。

---

在某些极端情况下，同步构造函数会很有用。这是一个更现实的例子，来自对 Bozho 答案的讨论：

public abstract class SuperClass {

   public SuperClass() {
       new Thread("evil") { public void run() {
          doSomethingDangerous();
       }}).start();
       try {
          Thread.sleep(5000);
       }
       catch(InterruptedException ex) { /* ignore */ }
   }

   public abstract void doSomethingDangerous();

}

public class SubClass extends SuperClass {
    int number;
    public SubClass () {
        super();
        number = 2;
    }

    public synchronized void doSomethingDangerous() {
        if(number == 2) {
            System.out.println("everything OK");
        }
        else {
            System.out.println("we have a problem.");
        }
    }

}

我们希望 doSomethingDangerous() 方法仅在我们的 SubClass 对象构建完成后调用，例如我们只想要“一切正常”的输出。但是在这种情况下，当您只能编辑您的子类时，您就没有机会实现这一点。如果构造函数可以同步，那问题就解决了。

因此，我们从中了解到：如果您的类不是最终类，则永远不要像我在超类构造函数中所做的那样 - 并且不要从您的构造函数中调用您自己类的任何非最终方法。

Answer 4

我认为没有理由禁止构造函数同步。它在多线程应用程序的许多场景中都很有用。如果我正确理解了 Java 内存模型（我阅读了 http://jeremymanson.blogspot.se/2008/11/what-volatile-means-in-java.html），那么下面的简单类可能会受益于同步构造函数。

public class A {
    private int myInt;

    public /*synchronized*/ A() {
        myInt = 3;
    }

    public synchronized void print() {
        System.out.println(myInt);
    }
}

理论上，我相信对print() 的调用可以打印“0”。如果 A 的实例由线程 1 创建，对实例的引用与线程 2 共享，并且线程 2 调用 print()，则可能会发生这种情况。如果 Thread 1 的 write myInt = 3 和 Thread 2 对同一字段的 read 之间没有特殊的同步，则不能保证 Thread 2 看到写入。

同步的构造函数可以解决这个问题。我说得对吗？

Answer 5

以下代码可以实现同步构造函数的预期结果。

public class SynchronisedConstructor implements Runnable {

    private int myInt;

    /*synchronized*/ static {
        System.out.println("Within static block");
    }

    public SynchronisedConstructor(){
        super();
        synchronized(this){
            System.out.println("Within sync block in constructor");
            myInt = 3;
        }
    }

    @Override
    public void run() {
        print();
    }

    public synchronized void print() {
        System.out.println(Thread.currentThread().getName());
        System.out.println(myInt);
    }

    public static void main(String[] args) {

        SynchronisedConstructor sc = new SynchronisedConstructor();

        Thread t1 = new Thread(sc);
        t1.setName("t1");
        Thread t2 = new Thread(sc);
        t2.setName("t2");

        t1.start();
        t2.start();
    }
}

Answer 6

这个问题已在 Java 并发 API 和 Java 内存模型的作者使用的讨论列表中提出。给出了几个答案，特别是Hans Boehm replied：

我们中的一些人（我自己包括 IIRC）实际上在 Java 内存模型审议期间认为应该允许同步构造函数。现在我可以选择任何一种方式。客户端代码不应该使用竞争来传达引用，所以它应该无关紧要。但是，如果您不信任 [您的班级] 的客户，我认为同步构造函数可能会有用。这就是最终字段语义背后的大部分原因。 [...] 正如 David 所说，您可以使用同步块。

Answer 7

JLS 中的Constructor Modifiers section 明确表示

There is no practical need for a constructor to be synchronized, because it would
lock the object under construction, which is normally not made available to other
threads until all constructors for the object have completed their work.

所以构造函数不需要同步。

另外，不建议在创建对象之前给出对象引用（this）。一种可能的模棱两可的情况是在创建子类对象时给出对象引用是超类构造函数。

Answer 8

这样的同步在极少数情况下可能有意义，但我想，这不值得：

• 您始终可以改用同步块
• 它会以一种非常奇怪的方式支持编码
• 它应该同步什么？ 构造函数是一种静态方法，它在对象上工作，但在没有它的情况下被调用。所以在类上同步也有（一些）意义！

如有疑问，请忽略它。

Answer 9

请注意，构造函数无法同步 - 将 synchronized 关键字与构造函数一起使用是语法错误。同步构造函数没有意义，因为只有创建对象的线程才能在构造对象时访问它。