Comment résoudre le “Double-Vérifier le Verrouillage est Cassé” Déclaration en Java?

Ici est l'idiome recommandé dans le Article 71: l'Utilisation d'initialisation tardive judicieusement de
Efficace Java:

Si vous avez besoin d'utiliser l'initialisation tardive pour les performances sur un
exemple de champ, utilisez la double-vérifier
l'idiome. Cet idiome évite le coût
de verrouillage lors de l'accès au terrain
après qu'il a été initialisé (Point
67). L'idée derrière l'idiome est à
vérifier la valeur de ce champ à deux reprises
(d'où le nom de double-vérifier): une fois
sans verrouillage, et puis, si l'
domaine semble être initialisée, une
deuxième fois avec verrouillage. Seulement si le
deuxième vérification indique que le champ
est non initialisé l'appel
initialiser le champ. Parce qu'il n'y est
pas de verrouillage si le champ est déjà
initialisé, il est critique que l'
champ déclaré volatile (Point
66). Ici est l'idiome:

//Double-check idiom for lazy initialization of instance fields
private volatile FieldType field;

private FieldType getField() {
    FieldType result = field;
    if (result != null) //First check (no locking)
        return result;
    synchronized(this) {
        if (field == null) //Second check (with locking)
            field = computeFieldValue();
        return field;
    }
}

Ce code peut paraître un peu compliqué.
En particulier, la nécessité pour les collectivités locales
la variable de résultat peut être incertaine. Ce
cette variable n'est de s'assurer que
le champ est en lecture seule fois dans la commune
cas où il est déjà initialisé.
Bien que pas strictement nécessaire, ce qui peut
améliorer les performances et est plus
élégant par les normes appliquées aux
faible niveau de la programmation simultanée. Sur
ma machine, la méthode ci-dessus est sur
25% plus rapide qu'à l'évidence
version sans une variable locale.

Avant la version 1.5, le double-vérifier
idiome n'étaient pas fiables parce que
la sémantique de la volatilité de l'modificateur
n'étaient pas assez solide pour le supporter
[Pugh01]. Le modèle de mémoire introduit
dans la version 1.5 a résolu ce problème
[JLS, 17, Goetz06 16]. Aujourd'hui, l'
double-vérifier l'idiome est la technique de
choix pour paresseusement d'initialisation d'un
champ d'instance. Alors que vous pouvez appliquer
le double-vérifier l'idiome de la statique
les champs ainsi, il n'y a pas de raison de
faire: l'initialisation titulaire
classe idiome est un meilleur choix.

De référence

• Efficace Java, Deuxième Édition
  • Article 71: l'Utilisation d'initialisation tardive judicieusement

DCL à l'aide ThreadLocal Par Brian Goetz @ JavaWorld

ce qui est cassé sur DCL?

DCL s'appuie sur une désynchronisation de l'utilisation de la ressource de terrain. Qui semble être inoffensif, mais il ne l'est pas. Pour comprendre pourquoi, imaginons qu'Un thread est à l'intérieur du bloc synchronisé, l'exécution de la déclaration de ressources = nouvelle Ressource(); tandis que le thread B est juste d'entrer dans getResource(). Prendre en compte l'effet sur la mémoire de cette initialisation. Mémoire pour le nouvel objet de la Ressource sera alloué; le constructeur de la Ressource sera appelé, d'initialiser les champs des membres de la nouvelle de l'objet; et le champ des ressources de SomeClass sera attribué une référence à l'objet nouvellement créé.

class SomeClass {
  private Resource resource = null;
  public Resource getResource() {
    if (resource == null) {
      synchronized {
        if (resource == null) 
          resource = new Resource();
      }
    }
    return resource;
  }
}

Cependant, depuis le thread B n'est pas de l'exécution à l'intérieur d'un bloc synchronisé, il peut voir ces opérations de mémoire dans un ordre différent de l'un thread s'exécute. Ce pourrait être le cas que B voit ces événements dans l'ordre suivant (et le compilateur est également libre de réorganiser les instructions de ce genre): allouer de la mémoire, d'attribuer la référence à la ressource, l'appel du constructeur. Supposons que le fil B vient après le mémoire a été allouée et la ressource champ est défini, mais avant que le constructeur est appelé. Il voit que la ressource n'est pas null, ignore le bloc synchronisé, et renvoie une référence à un partiellement construit de Ressources! Inutile de dire que le résultat n'est ni prévu ni souhaité.

Peut ThreadLocal de vous aider à résoudre DCL?

Nous pouvons utiliser ThreadLocal pour atteindre le DCL idiome de l'objectif explicite -- initialisation sans synchronisation sur la commune de chemin d'accès du code. Considérez ceci (thread-safe) version de DCL:

Listing 2. DCL à l'aide ThreadLocal

class ThreadLocalDCL {
  private static ThreadLocal initHolder = new ThreadLocal();
  private static Resource resource = null;
  public Resource getResource() {
    if (initHolder.get() == null) {
      synchronized {
        if (resource == null) 
          resource = new Resource();
        initHolder.set(Boolean.TRUE);
      }
    }
    return resource;
  }
}

Je pense; ici, chaque thread une fois entre dans la SYNCHRONISATION de bloc de mise à jour de la threadLocal valeur, alors elle ne sera pas. Donc ThreadLocal DCL permettra d'assurer un thread va entrer qu'une seule fois à l'intérieur de la SYNCHRONISATION de bloc.

Qu'est synchronisé signifie vraiment?

Java traite chaque thread comme si il fonctionne sur son propre processeur avec sa propre mémoire locale de chaque parler et la synchronisation avec un partage de la mémoire principale. Même sur un système monoprocesseur, ce modèle a un sens, car les effets de mémoire cache et l'utilisation de registres du processeur pour stocker des variables. Lorsqu'un thread modifie un emplacement dans son local de la mémoire, cette modification devrait éventuellement apparaître dans la mémoire principale, et le JMM définit les règles d'lorsque la JVM pour le transfert des données entre le local et la mémoire principale. La Java des architectes réalisé qu'une conception trop restrictive de la mémoire de modèle compromettrait sérieusement les performances du programme. Ils ont tenté d'élaborer un modèle de mémoire qui permettrait à des programmes de bien performer sur le matériel informatique moderne tout en offrant des garanties qui permettrait aux fils d'interagir de manière prévisible.

Java principal outil pour le rendu des interactions entre les threads de manière prévisible est le mot-clé synchronized. De nombreux programmeurs considèrent synchronisé strictement dans les termes de l'application d'un sémaphore d'exclusion mutuelle (mutex) pour empêcher l'exécution des sections critiques en plus d'un thread à la fois. Malheureusement, cette intuition n'est pas de décrire complètement ce synchronisé moyens.

La sémantique de la synchronisation ne comprend exclusion mutuelle d'exécution en se basant sur le statut d'un sémaphore, mais ils comprennent également les règles relatives à la synchronisation des threads, l'interaction avec la mémoire principale. En particulier, l'acquisition ou la libération d'un verrou déclenche une barrière de mémoire -- une synchronisation forcée entre le fil de la mémoire locale et la mémoire principale. (Certains processeurs, comme l'Alpha -- explicite d'instructions machine pour la réalisation de barrières de mémoire.) Lorsqu'un thread s'arrête en parallèle, un bloc, il effectue une barrière d'écriture, il doit se rincer toutes les variables modifiées dans ce bloc de mémoire principale avant de relâcher le verrou. De même, lors de la saisie d'un bloc synchronisé, il effectue une lecture de la barrière -- c'est comme si la mémoire locale a été invalidé, et il doit récupérer toutes les variables qui seront référencés dans le bloc à partir de la mémoire principale.

Définir la variable qui doit être vérifié en double avec volatile midifier

Vous n'avez pas besoin de la h variable.
Voici un exemple de ici

class Foo {
    private volatile Helper helper = null;
    public Helper getHelper() {
        if (helper == null) {
            synchronized(this) {
                if (helper == null)
                    helper = new Helper();
            }
        }
        return helper;
    }
}

Comme quelques-uns l'ont noté, vous avez certainement besoin de l' volatile mot-clé pour le faire fonctionner correctement, à moins que tous les membres de l'objet sont déclarés final, sinon il n'y a pas de passe-avant de pr coffre-publication et vous pouvez voir les valeurs par défaut.

Nous est tombée malade de la constante de problèmes avec les gens obtenir cette erreur, nous avons donc codé une LazyReference utilitaire qui a le dernier sémantique et a été le sujet d'articles et d'écoute pour être aussi rapide que possible.

Si je ne me trompe pas, il y a aussi une autre solution si nous ne voulons pas utiliser le mot clé volatile

par exemple en prenant l'exemple précédent

    class Foo {
        private Helper helper = null;
        public Helper getHelper() {
            if (helper == null) {
                synchronized(this) {
                    if (helper == null)
                        Helper newHelper = new Helper();
                        helper = newHelper;
                }
            }
            return helper;
        }
     }

le test est toujours sur l'aide de la variable, mais la construction de l'objet se fait juste avant la newHelper, ça évite d'avoir un partiellement construit objet