Jak zsynchronizować zmienną statyczną między wątkami obsługującymi różne instancje klasy w Javie?

Wiem, że użycie synchronizesłowa kluczowego przed metodą powoduje synchronizację z tym obiektem. Oznacza to, że zostaną zsynchronizowane 2 wątki z tym samym wystąpieniem obiektu.

Ponieważ jednak synchronizacja jest na poziomie obiektu, 2 wątki z różnymi instancjami obiektu nie zostaną zsynchronizowane. Jeśli w klasie Java mamy zmienną statyczną, która jest wywoływana przez metodę, chcielibyśmy, aby była zsynchronizowana między instancjami tej klasy. Te dwie instancje działają w 2 różnych wątkach.

Czy możemy osiągnąć synchronizację w następujący sposób?

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

Czy to prawda, że ​​skoro zdefiniowaliśmy obiekt, lockktóry jest statyczny i używamy słowa kluczowego synchronizeddla tej blokady, zmienna statyczna countjest teraz zsynchronizowana między instancjami klasy Test?

Istnieje kilka sposobów synchronizowania dostępu do zmiennej statycznej.

1. Użyj zsynchronizowanej metody statycznej. Spowoduje to synchronizację w obiekcie klasy.

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

2. Jawna synchronizacja w obiekcie klasy.

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

3. Zsynchronizuj z innym statycznym obiektem.

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

Metoda 3 jest najlepsza w wielu przypadkach, ponieważ obiekt blokady nie jest ujawniany poza klasą.

Jeśli po prostu udostępniasz licznik, rozważ użycie AtomicInteger lub innej odpowiedniej klasy z pakietu java.util.concurrent.atomic:

public class Test {

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

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

Tak to jest prawda.

Jeśli utworzysz dwie instancje swojej klasy

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

Następnie t1.foo i t2.foo synchronizują się na tym samym obiekcie statycznym i blokują się wzajemnie.

Możesz zsynchronizować swój kod z klasą. To byłoby najprostsze.

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

Mam nadzieję, że ta odpowiedź okaże się przydatna.

Możemy również użyć ReentrantLock, aby uzyskać synchronizację dla zmiennych statycznych.

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();
    }  
}