为什么Java构造函数无法同步？

Question

根据Java语言规范，无法将构造函数标记为已同步，因为其他线程在创建该对象的线程完成之前无法看到正在创建的对象。这似乎有些奇怪，因为在构造对象时，我确实可以让另一个线程查看该对象：

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

我知道这是一个非常人为的示例，但从理论上讲，似乎有人可以提出一个更现实的案例，在该案例中，标记构造函数为同步状态是合法的，以防止此类线程的竞争。

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

Answer 1

如果您确实需要将构造函数的其余部分与任何线程进行同步，而这些线程无论如何都能引用尚未完全构造的对象，则可以使用synced-block：

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
       }
    }
}

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

在某些特殊情况下，同步构造函数会很有用。通过讨论博佐的答案，这是一个更现实的示例：

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对象后才调用该方法，例如，我们只希望“一切正常”输出。但是在这种情况下，当您只能编辑子类时，您将没有机会实现这一目标。如果构造函数可以同步，则可以解决问题。

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