Почему нельзя синхронизировать конструкторы 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

Если вам действительно нужна синхронизация остальной части конструкторы против любых потоков, которые так или иначе получает ссылку на ваш пока еще не полностью построенный объект, вы можете использовать синхронизированный-блок:

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 2

Потому что synchronized гарантирует, что действия на одних и тех же объектах не должны выполняться несколькими потоками. И когда конструктор называется, у вас все еще нет объекта. Логически невозможно, чтобы два потока обращались к конструктору того же объекта.

В вашем примере, даже если метод вызван новым потоком, это уже не о конструкторе - речь идет о синхронизируемом целевом методе.

Answer 3

В вашем примере конструктор фактически вызывается только один раз из одного потока.

Да, вы можете получить ссылку на неполностью сконструированный объект (некоторые обсуждения вокруг блокировки двойной проверки и почему это ломается, выявить эту проблему), однако, не путем вызова конструктора во второй раз.

Синхронизированный конструктор предотвратит одновременное вызов двух потоков из одного конструктора на одном и том же объекте, и это невозможно, так как никогда невозможно вызвать конструктор экземпляра объекта дважды, период.

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, ссылка на экземпляр разделяется с помощью Thread 2, а Thread 2 вызывает print(). Если нет специальной синхронизации между записью myInt = 3 Thread 1 и чтением того же поля по Thread 2, 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, что синхронизированные конструкторы должны быть разрешены. Теперь я мог бы пойти в любом случае. Клиентский код не должен использовать расы для передачи ссылки, поэтому это не имеет значения. Но если вы не доверяете клиентам [вашего класса], я думаю, что синхронизированные конструкторы могут быть полезны. И это было большим аргументом в пользу окончательной полевой семантики. [...] Как сказал Дэвид, вы можете использовать синхронизированные блоки.

Answer 7

Constructor Modifiers section в JLS ясно говорит

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. 

Так что нет никакой необходимости в конструктор для синхронизации.

Также не рекомендуется указывать ссылку на объект (это) перед созданием объекта. Одна из возможных неоднозначных ситуаций заключалась бы в том, чтобы указать ссылку на объекты - конструктор суперкласса при создании объекта подкласса.

Answer 8

Такая синхронизация может иметь смысл в некоторых очень редких случаях, но я думаю, это просто не стоит:

• вы всегда можете использовать синхронизированный блок вместо
• было бы поддерживать кодирование в довольно странный способ
• на что он должен синхронизироваться? Конструктор - это своего рода статический метод, он работает над объектом, но получает его без него. Поэтому синхронизация по классу также делает (некоторые) смысл!

Если у вас есть сомнения, оставьте это.