Comment synchroniser une variable statique parmi les threads exécutant différentes instances d'une classe en Java?

Je sais que l'utilisation du synchronizemot - clé avant une méthode apporte la synchronisation à cet objet. Autrement dit, 2 threads exécutant la même instance de l'objet seront synchronisés.

Cependant, puisque la synchronisation est au niveau de l'objet, 2 threads exécutant différentes instances de l'objet ne seront pas synchronisés. Si nous avons une variable statique dans une classe Java qui est appelée par la méthode, nous aimerions qu'elle soit synchronisée entre les instances de la classe. Les deux instances s'exécutent dans 2 threads différents.

Pouvons-nous réaliser la 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 puisque nous avons défini un objet lockqui est statique et que nous utilisons le mot-clé synchronizedpour ce verrou, la variable statique countest maintenant synchronisée entre les instances de la classe Test?

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

1. Utilisez une méthode statique synchronisée. Cela se synchronise sur l'objet de classe.

   public class Test {
       private static int count = 0;
   
       public static synchronized void incrementCount() {
           count++;
       }
   } 

2. Synchronisez explicitement sur l'objet de classe.

   public class Test {
       private static int count = 0;
   
       public void incrementCount() {
           synchronized (Test.class) {
               count++;
           }
       }
   } 

3. Synchronisez 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 la meilleure dans de nombreux cas car l'objet de verrouillage n'est pas exposé en dehors de votre classe.

Si vous partagez simplement un compteur, envisagez d'utiliser un AtomicInteger ou une autre classe appropriée du package java.util.concurrent.atomic:

public class Test {

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

    public void foo() {  
        count.incrementAndGet();
    }  
}

Oui c'est vrai.

Si vous créez deux instances de votre classe

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

Ensuite, t1.foo et t2.foo se synchronisent tous les deux sur le même objet statique et se bloquent donc mutuellement.

Vous pouvez synchroniser votre code sur la classe. Ce serait le 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++;  
         }  
      }  
    }

J'espère que vous trouverez cette réponse utile.

Nous pouvons également utiliser ReentrantLock pour réaliser la synchronisation des variables statiques.

public class Test {

    private static int count = 0;
    private static final ReentrantLock reentrantLock = new ReentrantLock(); 
    public void foo() {  
        reentrantLock.lock();
        count = count + 1;
        reentrantLock.unlock();
    }  
}