Pourquoi ne peut-Java constructeurs être synchronisées?

Selon la Spécification du Langage Java, les constructeurs ne peuvent pas être marquées synchronisé parce que les autres threads ne peuvent pas voir l'objet en cours de création jusqu'à ce que le fil de la création, il l'a terminé. Cela semble un peu bizarre, parce que je ne peux en effet avoir un autre thread voir l'objet, alors qu'il est en cours de construction:

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

Je sais que c'est un joli exemple artificiel, mais il semble que dans la théorie que quelqu'un pourrait trouver une façon plus réaliste cas où le marquage le constructeur synchronisé serait légitime afin de prévenir les courses avec son fils comme celui-ci.

Ma question est la suivante: est-il une raison que Java serait d'interdire le modificateur synchronized sur un constructeur? Peut-être que mon exemple ci-dessus est erronée, ou peut-être il n'y a vraiment aucune raison et c'est une conception arbitraire de la décision. Dans les deux cas, je suis très curieux et j'aimerais vraiment connaître la réponse.

  • En aparté, il est fortement recommandé de ne pas autoriser le "ce" de référence pour s'échapper avant que le constructeur a terminé.
  • Q - j'ai entendu cela avant, mais ne comprennent pas bien pourquoi. Est-il une raison particulière? J'ai pu voir de Mauvaises Choses qui se passe si vous avez donné une référence à cette avant que vous avez terminé l'initialisation de l'objet, mais que si c'est la dernière chose que vous faites dans le constructeur?
  • c'est vraiment l'objet d'une autre question, mais même si c'est la dernière chose que vous faites dans le constructeur, si l'objet est sous-classé, puis la sous-classe n'a pas fini de construire. Si cette classe est définitive, et vous n'avez pas la chaîne de constructeurs (à l'appel de cette(...)) et de faire autre chose après la chaîne appel et c'est la dernière chose que vous faites, de son amende. Sauf, bien sûr, que l'une de ces décisions sont susceptibles de changer (vous pouvez ajouter un deuxième constructeur plus tard).
  • C'est beaucoup plus clair si vous citer ce que le JLS dit en réalité: "Il n'y a pas de pratique besoin d'un constructeur de la synchronisation, car elle permettrait de verrouiller l'objet en cours de construction, qui est normalement ne sont pas disponibles pour les autres threads jusqu'à ce que tous les constructeurs de l'objet, ont terminé leur travail."
  • voir ibm.com/developerworks/java/library/j-jtp0618.html pour plus de détails
  • De la Java Tutoriel (lien) "Attention: Lors de la construction d'un objet qui sera partagé entre les threads, faire très attention à ce qu'une référence à l'objet n'a pas de "fuite" prématurément. Par exemple, supposons que vous voulez maintenir une Liste appelée instances contenant toutes les instances d'une classe. Vous pourriez être tenté d'ajouter la ligne suivante à votre constructeur: instances.add(this); Mais alors les autres threads peuvent utiliser des instances d'accès à l'objet avant la construction de l'objet est terminée."
  • En plus de la remarque précédente, la Java Tutoriel dit, dans la même leçon, que vous ne pouvez pas utiliser le " synchronisé mot-clé dans un constructeur, puis il indique le message d'avertissement dans le commentaire précédent. Cela semble contradictoire pour moi, et j'espère que, dans l'avenir, les constructeurs seront synchronisés par défaut sur l'objet créé. C'est ce qui semble le plus raisonnable à mon humble avis, car, autrement, vous accédez à un objet dans un état incohérent.

InformationsquelleAutor templatetypedef | 2011-02-02
  1. 30

    Si vous avez vraiment besoin de synchronisation du reste du constructeur contre tout les threads qui, de toute façon, obtient une référence à votre n'est pas encore totalement construit un objet, vous pouvez utiliser une synchronisation de bloc:

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

    Il est généralement considéré mauvais style de "donner" votre pas-encore-objet construit, donc, en parallèle, un constructeur n'est pas nécessaire.

    Dans certains cas de coin en parallèle, un constructeur serait utile. Voici un exemple plus réaliste exemple, à partir de la discussion de Bozho réponse:

    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.");
        }
    }

}

    Nous voulons que le doSomethingDangerous() méthode n'est appelée qu'après la construction de notre objet sous-classe est complète, par exemple, nous voulons seulement le "tout est OK" de sortie. Mais dans ce cas, lorsque vous ne pouvez modifier votre sous-classe, vous n'avez aucune chance d'y parvenir. Si le constructeur pourrait être synchronisée, elle permettrait de résoudre le problème.

    Donc, ce que nous apprenons à ce sujet: ne jamais faire quelque chose comme je l'ai fait ici dans le constructeur de la superclasse, si votre classe n'est pas définitive et ne pas appeler n'importe quel non-finale méthodes de votre classe à partir de votre constructeur.

    • ahh, me battre pour elle 🙂 +1
    • votre exemple est très artificiel. Tout d'abord, ce serait une mauvaise pratique pour appeler une méthode abstraite à partir d'un constructeur, mais plus important encore, si il n'y avait pas de thread va sur le sous-classe aurait exactement sur le même problème. De manière synchronisée permettrait d'ajouter quoi? Soutien pour une très probable, tout en provoquant la sous-classe de toute façon de contourner les cas beaucoup plus fréquent dans une manière qui pourrait avoir travaillé pour les deux cas.
    • Vous avez raison, l'exemple n'est pas réaliste. Mais j'ai vu des classes qui publient leurs propres objets dans le constructeur pour les autres threads (pas forcément dans la même classe, et pas forcément avec un sommeil), et puis vous pouvez avoir de tels problèmes en parallèle, un constructeur pourrait aider. Bien sûr, cette méthode dans mon exemple doit se protéger lui-même pour être appelé à partir du constructeur de la superclasse.
    • Je ne suis pas convaincu que c'est un bon exemple, soit, principalement du fait de sa mauvaise pratique pour démarrer un thread à l'intérieur d'un constructeur.
    • Merci pour la modification de la proposition, mais le premier exemple n'a pas besoin de la abstract. Le second, en cas de besoin, bien que – je l'ai ajouté ici.
    InformationsquelleAutor Paŭlo Ebermann
  2. 16

    La question a été soulevée sur une liste de discussion utilisé par les rédacteurs de la Java simultanées de l'API et la Java du Modèle de Mémoire. Plusieurs réponses ont été données, en particulier Hans Boehm a répondu:

    Certains d'entre nous (moi y compris l'IIRC) fait valoir au cours de la Java du modèle de mémoire de délibérations qui synchronisé les constructeurs devraient être autorisés. Maintenant, je pouvais aller de toute façon sur elle. Code Client ne doit pas utiliser des courses pour communiquer la référence, donc il ne devrait pas d'importance. Mais si vous ne faites pas confiance aux clients de [votre classe], je pense que synchronisés constructeurs pourraient éventuellement être utile. Et c'était bien le raisonnement final de champ sémantique. [...] Comme le dit David, vous pouvez utiliser des blocs synchronisés.

    • Je ne suis pas aller, comment il est logique de discuter de la question de savoir si le langage doit permettre ou pas, surtout quand les autres disent que ça n'a pas de sens parce que "lorsque le constructeur est appelé vous ne l'avez pas encore l'objet (pour synchroniser)". Donc je pense que ses tout simplement impossible à même de mettre en œuvre par le langage. Ou il y a quelque chose qui me manque?
    • imaginez un static MyObject o; - 1 thread exécute o = new MyObject(); tandis que le thread 2 appels o.getSomething();. Il y a une condition de course et le thread 2 pu observer une partie objet construit. Si le constructeur et getSomething ont été synchronisés, vous avez la garantie de voir l'objet dans un état cohérent. D'où le commentaire dans la citation ci-dessus "le code Client ne doit pas utiliser des courses pour communiquer la référence, donc il ne devrait pas.".
    InformationsquelleAutor assylias
  3. 8

    Parce que synchronized garantit que les actions sur les mêmes objets ne doivent pas être exécutées par plusieurs threads. Et lorsque le constructeur est appelé vous ne l'avez pas encore l'objet. Il est logiquement impossible que deux threads d'accéder au constructeur de l'objet même.

    Dans votre exemple, même si une méthode est appelée par le nouveau thread, il n'est plus sur le constructeur - c'est à propos de l'objectif méthode en cours de synchronisation ou pas.

    • Il est exact que les deux threads ne peuvent pas à la fois appel au constructeur, mais que si un thread appelle le constructeur, qui puis déclenche un autre thread qui tente d'invoquer une autre méthode synchronisée de la classe? Dans ce cas, avoir un synchronisé constructeur de prévenir la deuxième thread à se prévaloir de tout synchronisé méthodes jusqu'à ce que le constructeur résilié.
    • ce n'est pas le constructeur, mais à propos de la méthode en question.
    • Ils vous pouvez faire un synchronized(this) {} à l'intérieur de votre constructeur. Synchronisé sur le constructeur lui-même est un non-sens. Comment voulez-vous acquérir le mutex à un objet avant de commencer le processus de l'amener à l'existence?
    • La JVM de code pour la création d'un objet en deux étapes - l'allocation de l'objet avec tous les champs par défaut-initialisé, puis d'appeler le constructeur. Dans cette étape, il semble tout à fait raisonnable de définir l'objet du moniteur, ce qui pourrait permettre au constructeur d'être marqué synchronisé.
    • le constructeur est déjà invoquées. Vous ne pouvez pas invoquer le constructeur de cet objet nouveau. Vous pouvez appeler les méthodes de là, mais les méthodes ont synchronized
    • euh, un downvote? Quel est le problème avec l'explication?
    • (Je n'étais pas le downvoter.) L'explication par templatetypedef faire sence: Si vous ne voulez pas une méthode synchronisée de votre classe (ou un sous - ou super-classe) pour être exécuté par un autre thread avant votre constructeur est fini, et peut-être même le constructeur de la superclasse publie votre objet, vous avez perdu – même un bloc synchronisé dans le constructeur (comme dans ma réponse) n'aide pas, car il ne s'applique pas au constructeur de la superclasse.
    • Ebermann comme je l'ai dit - si vous souhaitez synchroniser des méthodes, ainsi, de synchroniser les méthodes, le constructeur n'a rien à faire avec elle.
    • Il a, si vous voulez éviter que ces méthodes sont exécutées simultanément avec le constructeur. Seulement les méthodes synchronisées ne sont pas utiles ici. C'est (maintenant) possible uniquement lorsque vous utilisez un bloc synchronisé à l'intérieur de votre constructeur, qui n'a toujours pas d'aide pour le constructeur de la superclasse.
    • Ebermann maintenant, imaginez votre exemple, mais avec une méthode. c'est le même scénario, vous disposez de deux méthodes qui doivent synchroniser leur exécution. Il est complètement différent du scénario de la synchronisés signature modificateur
    • (Je vais ajouter un exemple de ma réponse, car ici dans les commentaires, je ne peux pas vraiment écrire de code.)
    • vos commentaires sont sans importance pour templatetypedef commentaire. Le modèle est de parler du bytecode niveau, où il est en fait possible de faire des opérations sur des objets non, et en soulignant que la machine virtuelle pourrait être conçu de sorte que vous pouvez synchroniser sur des objets non initialisées ainsi.
    • Je pense (c'était il y a longtemps) que je voulais le suivant: même si c'est en deux étapes: initialisation et l'appel du constructeur, et les autres threads peuvent voir les initialisé objet, ils ne peuvent pas invoquer la 2ème étape sur elle. Sur la JVM niveau, ils peuvent probablement, mais on ne peut l'exprimer que dans du code Java

    InformationsquelleAutor Bozho
  4. 5

    Dans votre exemple, le constructeur n'est appelé qu'une seule fois à partir d'un thread.

    Oui, il est possible d'obtenir une référence à une incomplètement Objet construit (certaines discussions autour d'un double contrôle de verrouillage et pourquoi il est cassé révéler ce problème), cependant, pas en appelant le constructeur une deuxième fois.

    Synchronisées sur le constructeur de prévenir les deux fils de l'appel du constructeur, sur le même Objet en même temps, et ce n'est pas possible, comme il n'est jamais possible d'appeler le constructeur sur une instance de l'objet à deux reprises, période.

    • Downvoter, n'importe quelle raison?
    • Je n'ai pas downvote, mais une raison possible: synchronisé sur le constructeur ne serait pas seulement d'éviter les deux fils d'appeler le constructeur de la même thread (ce qui est impossible de toute façon), mais aussi d'éviter l'appel d'une méthode synchronisée de cet objet (ou de la saisie d'un bloc synchronisé avec cet objet en tant que paramètre) dans un autre thread.
    InformationsquelleAutor Yishai
  5. 5

    Constructeur de la section de Modificateurs dans JLS dit clairement

    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.

    Donc il n'est pas nécessaire pour le constructeur à être synchronisés.

    Aussi il n'est pas recommandé de donner les objets de référence(ce) avant la création de l'objet. Une des situations ambiguës serait de donner les objets de référence est le constructeur de la superclasse quand subsclass objet est créé.

    • Vous pourriez syncrhonize sur autre chose.
    InformationsquelleAutor Aniket Thakur
  6. 3

    Je vois peu de raisons d'interdire les constructeurs à être synchronisés. Il serait utile dans de nombreux scénarios dans les applications multi-thread. Si je comprends la Java de la Mémoire de Modèle correcte (j'ai lu http://jeremymanson.blogspot.se/2008/11/what-volatile-means-in-java.html) le simple classe pourrait avoir bénéficié d'un synchronisé constructeur.

    public class A {
    private int myInt;

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

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

    En théorie, je crois qu'un appel à print() pourrait impression de "0". Cela peut se produire si une instance de A est créé par le Thread 1, la référence de l'instance est partagée avec le Thread 2, et le Thread 2 appels print(). Si il n'y a pas de synchronisation entre l'écriture myInt = 3 de Fil 1 et le lire de la même champ par le Thread 2 Thread 2 n'est pas assuré de voir l'écriture.

    En parallèle, un constructeur de corriger ce problème. Suis-je le droit à ce sujet?

    • (i) le problème que vous décrivez est que l'instance de l'Un n'est pas correctement publié, auquel cas observés de l'état pourrait être n'importe quoi, en effet, (ii) vous pouvez écrire synchronized (this) { myInt = 3; } dans votre constructeur pour résoudre le problème, ou la marque myInt comme définitive.
    • Vous pouvez également marquer des myInt variable avec volatile mot-clé.
    • Pas nécessairement. Si le renvoi de l'objet est une fuite à un autre thread avant qu'il est entièrement construit, puis l'autre thread peut appeler non synchronisée méthode de cet objet en tant que bien, dans ce cas la synchronisation le constructeur n'aide jamais. En évitant le plus tard donc pas de fuite doit être pratiqué, par la suite, la synchronisation, le constructeur devient inutile.
    • Pas de. Dans votre cas, le Thread 1 n'aurait pas une instance de A jusqu'à ce que son constructeur avait terminé, il ne serait pas en mesure de le partager avec le Thread 2. Même si c'était possible, il vous suffit d'enrouler le code du constructeur à l'intérieur d'un synchronized bloc et obtenir le même effet.
    • Cela n'a rien à avec cette fuite dans le constructeur, en plus avec ce que le JIT/optimiseur ne. - Il est autorisé à re-commander des trucs, mais pas au-delà de synchronisation des actions. Donc, sans le constructeur de synchronisation, le constructeur peut revenir mais le myInt champ vit toujours dans un registre, pas dans la mémoire. Donc, dans l'autre thread prêt à 0.
    InformationsquelleAutor Frans Lundberg
  7. 0

    Le code suivant peut atteindre le résultat attendu pour la synchronisation de constructeur.

    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();
    }
}
    InformationsquelleAutor Nimesh
  8. 0

    Une telle synchronisation peut avoir du sens dans certains cas très rares, mais je pense, c'est juste pas la peine:

    • vous pouvez toujours utiliser un bloc synchronisé au lieu
    • il avait le soutien de codage dans une jolie manière étrange
    • sur quoi devrait-il synchroniser? Un constructeur est une sorte de méthode statique, il fonctionne sur un objet, mais est appelée sans elle. Si la synchronisation de la classe fait aussi (un peu) les sens!

    En cas de doute, laisser.

    InformationsquelleAutor maaartinus
  9. 0

    Remarque que les constructeurs ne peuvent pas être synchronisés, en utilisant le synchronizedkeyword avec un constructeur est une erreur de syntaxe. La synchronisation des constructeurs n'a pas de sens, parce que seul le thread qui crée un objet devrait y avoir accès alors qu'il est en cours de construction.

    InformationsquelleAutor sarir