Pourquoi le verrouillage à double vérification est-il cassé en Java?

Question

Il est indiqué que l'affectation des champs est toujours atomique, sauf pour les champs de long ou double.

Mais, quand je lis une explication des raisons pour lesquelles le verrouillage à double contrôle est cassé, il est dit que le problème est en opération d'affectation:

// Broken multithreaded version 
// "Double-Checked Locking" idiom 
class Foo { 
    private Helper helper = null; 
    public Helper getHelper() { 
     if (helper == null) { 
      synchronized(this) { 
       if (helper == null) { 
        helper = new Helper(); 
       } 
      } 
     } 
     return helper; 
    } 

    // other functions and members... 
} 

1. Discussion A avis que la valeur n'est pas initialisé , donc il obtient le verrou et commence à initialiser la valeur .
2. En raison de la sémantique de certains langages de programmation, le code généré par le compilateur est autorisé pour mettre à jour la variable partagée pour pointer vers un objet partiellement construit avant A a fini d'effectuer l'initialisation .
3. Le thread B remarque que la variable partagée a été initialisée (ou alors apparaît) et renvoie sa valeur. Étant donné que thread B croit que la valeur est déjà initialisé, il pas acquérir le verrou. Si B utilise l'objet avant tout l'initialisation fait par A est vu par B (soit parce qu'un n'a pas terminé l'initialisation ou parce que certaines des valeurs initialisées dans l'objet ont pas encore percolé à la mémoire B utilise (cache cohérence)), le programme va probablement crash.
   (à partir de http://en.wikipedia.org/wiki/Double-checked_locking).

Quand est-ce possible? Est-il possible que l'opération d'assignation JVM 64 bits ne soit pas atomique? Si non alors si le "double-checked locking" est vraiment cassé?

Answer 1

Le problème n'est pas l'atomicité, c'est la commande. La JVM est autorisée à réorganiser les instructions afin d'améliorer les performances, tant que happens-before n'est pas violé. Par conséquent, le moteur d'exécution peut théoriquement planifier l'instruction qui met à jour helper avant que toutes les instructions du constructeur de la classe Helper aient été exécutées.

Answer 2

Plusieurs affectations peuvent être nécessaires pour construire l'instance de Helper à l'intérieur du constructeur, et la sémantique permet de les réorganiser par rapport à l'affectation helper = new Helper(). Par conséquent, le champ helper peut recevoir une référence à un objet lorsque toutes les affectations n'ont pas été effectuées, de sorte qu'il est incomplètement initialisé.

Answer 3

revérifié verrouillage en java a une variété de problèmes:

http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

Answer 4

L'affectation de la référence est atomique, mais la construction n'est pas! Comme indiqué dans l'explication, supposons que le thread B veut utiliser le singleton avant que le thread A ne l'ait entièrement construit, il ne peut pas créer une nouvelle instance car la référence n'est pas nulle, donc il renvoie juste l'objet partiellement construit.

Si vous ne vous assurer que la publication la référence partagée se produit avant une autre charge de fil qui ont partagé de référence, la écriture de la référence au nouvel objet peut être réorganisés avec les écritures à ses champs .Dans ce cas, un autre thread pouvait voir une valeur à jour pour la référence d'objet mais des valeurs obsolètes pour tout ou partie de l'objet de l'objet - un objet partiellement construit. - Brian Goetz: Java Concurrency en pratique

Puisque la vérification initiale de null n'est pas synchronisée, il n'y a pas de publication et cette réorganisation est possible.

Answer 5

Lisez cet article: http://www.javaworld.com/jw-02-2001/jw-0209-double.html Même si vous n'avez pas compris tous les détails (comme moi), il suffit de croire que cette belle astuce ne fonctionne pas.

Answer 6

Je suis désolé que ce soit un peu hors de propos pour la question, je suis juste curieux. Dans ce cas, ne vaut-il pas mieux acquérir le verrou avant l'affectation et/ou renvoyer la valeur? Comme:

private Lock mLock = new ReentrantLock(); 
private Helper mHelper = null; 

private Helper getHelper() { 
    mLock.lock(); 
    try { 
     if (mHelper == null) { 
      mHelper = new Helper(); 
     } 
     return mHelper; 
    } 
    finally { 
     mLock.unlock(); 
    } 
} 

Ou y a-t-il un avantage quelconque à utiliser le verrouillage à double contrôle?

Answer 7

/*Then the following should work. 
    Remember: getHelper() is usually called many times, it is BAD 
    to call synchronized() every time for such a trivial thing! 
*/ 
class Foo { 

private Helper helper = null; 
private Boolean isHelperInstantiated; 
public Helper getHelper() { 
    if (!isHelperInstantiated) { 
     synchronized(this) { 
      if (helper == null) { 
       helper = new Helper(); 
       isHelperInstantiated = true; 
      } 
     } 
    } 
    return helper; 
} 

// other functions and members... 
}