Comment synchroniser une variable statique entre les threads qui exécutent différentes instances d'une classe en Java?

Je sais que l'utilisation de la synchronize mot-clé avant une méthode apporte la synchronisation de l'objet. C'est, 2 threads s'exécutant sur la même instance de l'objet seront synchronisés.

Cependant, depuis la synchronisation est au niveau de l'objet, 2 threads s'exécutant différentes instances de l'objet ne seront pas synchronisées. Si nous avons une variable statique dans une classe Java qui est appelée par la méthode, que l'on voudrait être synchronisés sur l'ensemble des instances de la classe. Les deux instances sont en cours d'exécution dans les 2 threads différents.

Pouvons-nous obtenir une synchronisation de la manière suivante? 

public class Test  
{  
   private static int count = 0;  
   private static final Object lock= new Object();    
   public synchronized void foo() 
  {  
      synchronized(lock)
     {  
         count++;  
     }  
  }  
}

Est-il vrai que, depuis, nous avons défini un objet lock qui est statique et nous utilisons le mot-clé synchronized pour que le verrouillage, la variable statique count est maintenant synchronisé entre les instances de la classe Test?

  • toutes ces réponses sont INUTILES à moins que le verrou de l'objet est déclarée FINAL!
  • Regardez aussi java.util.de façon concomitante.atomique.AtomicInteger
InformationsquelleAutor Anonymous | 2010-01-22
  1. 191

    Il existe plusieurs façons de synchroniser l'accès à une variable statique.

    1. Utiliser un synchronisé méthode statique. Il synchronise sur la classe de l'objet.

      public class Test {
    private static int count = 0;

    public static synchronized void incrementCount() {
        count++;
    }
}

    2. Explicitement synchroniser sur la classe de l'objet.

      public class Test {
    private static int count = 0;

    public void incrementCount() {
        synchronized (Test.class) {
            count++;
        }
    }
}

    3. Synchroniser sur un autre objet statique.

      public class Test {
    private static int count = 0;
    private static final Object countLock = new Object();

    public void incrementCount() {
        synchronized (countLock) {
            count++;
        }
    }
}

    La méthode 3 est le meilleur, dans de nombreux cas, parce que le verrou de l'objet n'est pas exposée à l'extérieur de votre classe.

    • 1. le premier n'a pas besoin d'un verrouillage de l'objet, ne devrait-elle pas être le meilleur?
    • 2. déclarer comte de volatiles seraient également des œuvres, alors que la volatilité permet de s'assurer que la variable est synchronisé.
    • La raison #3 est le meilleur, c'est que n'importe quel morceau de code peut se synchroniser sur les Test.class et potentiellement gâcher votre journée. Aussi, initialisation de classe s'exécute avec un verrou sur la tenue de classe, donc si vous avez des classe folle initialiseurs vous pouvez donner vous-même des maux de tête. volatile n'aide pas pour count++ parce que c'est une lecture / modification / écriture de la séquence. Comme indiqué dans une réponse différente, java.util.concurrent.atomic.AtomicInteger est probablement le bon choix ici.
    • N'oubliez pas de synchroniser l'opération de lecture sur le comte, si vous voulez lire la valeur correcte comme indiqué par d'autres threads. Déclarant volatile (en plus synchronisés écrire) sera également vous aider à cela.
    • non, vous sont le verrouillage de Test.class . this serait la serrure pour la synchronisation de la non-static méthodes
    InformationsquelleAutor Darron
  2. 64

    Si vous êtes tout simplement le partage d'un compteur, envisager l'utilisation d'un AtomicInteger ou d'une autre, adapté de la classe de java.util.de façon concomitante.atomique package:

    public class Test {

    private final static AtomicInteger count = new AtomicInteger(0); 

    public void foo() {  
        count.incrementAndGet();
    }  
}
    • Il est disponible en java 1.5, pas en 1.6.
    InformationsquelleAutor Kevin
  3. 4

    Oui, c'est vrai.

    Si vous créez deux instance de votre classe

    Test t1 = new Test();
Test t2 = new Test();

    Alors t1.foo et t2.foo à la fois de synchroniser sur le même objet statique et donc de bloquer les uns les autres.

    • on va bloquer les autres, pas les uns les autres à la fois si pris en charge.
    InformationsquelleAutor richs
  4. -1

    Vous pouvez synchroniser votre code sur la classe. Ce serait plus simple. 

       public class Test  
    {  
       private static int count = 0;  
       private static final Object lock= new Object();    
       public synchronized void foo() 
      {  
          synchronized(Test.class)
         {  
             count++;  
         }  
      }  
    }

    Espérons que vous trouverez cette réponse utile.

    • Cela fonctionne, mais comme mentionné ailleurs par @Fadden, méfiez-vous que n'importe quel autre thread pourrait aussi se synchroniser sur Test.class et influer sur le comportement. C'est pourquoi la synchronisation sur les lock pourrait être préférée.
    • Ce que vous dites est correct. C'est pourquoi je mentionner clairement qu'il s'agit de l'approche la plus simple.
    InformationsquelleAutor Jafar Ali