Wie synchronisiere ich eine statische Variable zwischen Threads, auf denen verschiedene Instanzen einer Klasse in Java ausgeführt werden?

Ich weiß, dass die Verwendung des synchronizeSchlüsselworts vor einer Methode die Synchronisation für dieses Objekt bewirkt. Das heißt, 2 Threads, auf denen dieselbe Instanz des Objekts ausgeführt wird, werden synchronisiert.

Da sich die Synchronisation jedoch auf Objektebene befindet, werden 2 Threads, auf denen verschiedene Instanzen des Objekts ausgeführt werden, nicht synchronisiert. Wenn wir eine statische Variable in einer Java-Klasse haben, die von der Methode aufgerufen wird, möchten wir, dass sie über Instanzen der Klasse hinweg synchronisiert wird. Die beiden Instanzen werden in zwei verschiedenen Threads ausgeführt.

Können wir die Synchronisation auf folgende Weise erreichen?

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

Stimmt es, dass die statische Variable jetzt über Klasseninstanzen hinweg synchronisiert ist, da wir ein lockstatisches Objekt definiert haben und das Schlüsselwort synchronizedfür diese Sperre verwenden ?countTest

Es gibt verschiedene Möglichkeiten, den Zugriff auf eine statische Variable zu synchronisieren.

1. Verwenden Sie eine synchronisierte statische Methode. Dies wird auf dem Klassenobjekt synchronisiert.

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

2. Explizite Synchronisierung für das Klassenobjekt.

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

3. Synchronisieren Sie mit einem anderen statischen Objekt.

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

Methode 3 ist in vielen Fällen die beste, da das Sperrobjekt nicht außerhalb Ihrer Klasse verfügbar gemacht wird.

Wenn Sie lediglich einen Zähler freigeben , sollten Sie eine AtomicInteger oder eine andere geeignete Klasse aus dem Paket java.util.concurrent.atomic verwenden:

public class Test {

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

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

Ja, das ist wahr.

Wenn Sie zwei Instanzen Ihrer Klasse erstellen

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

Dann synchronisieren sich t1.foo und t2.foo beide auf demselben statischen Objekt und blockieren sich daher gegenseitig.

Wir können auch ReentrantLock verwenden , um die Synchronisation für statische Variablen zu erreichen.

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

Sie können Ihren Code über die Klasse synchronisieren. Das wäre am einfachsten.

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

Ich hoffe, Sie finden diese Antwort hilfreich.