¿Cómo sincronizar una variable estática entre subprocesos que ejecutan diferentes instancias de una clase en Java?

Sé que usar la synchronizepalabra clave antes de un método trae sincronización a ese objeto. Es decir, se sincronizarán 2 subprocesos que ejecutan la misma instancia del objeto.

Sin embargo, dado que la sincronización se realiza a nivel de objeto, no se sincronizarán 2 subprocesos que ejecutan diferentes instancias del objeto. Si tenemos una variable estática en una clase Java a la que llama el método, nos gustaría que se sincronizara en todas las instancias de la clase. Las dos instancias se ejecutan en 2 subprocesos diferentes.

¿Podemos lograr la sincronización de la siguiente manera?

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

¿Es cierto que, dado que hemos definido un objeto lockque es estático y estamos usando la palabra clave synchronizedpara ese bloqueo, la variable estática countahora está sincronizada en todas las instancias de la clase Test?

Hay varias formas de sincronizar el acceso a una variable estática.

1. Utilice un método estático sincronizado. Esto se sincroniza con el objeto de clase.

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

2. Sincronizar explícitamente en el objeto de clase.

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

3. Sincronice con algún otro objeto estático.

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

El método 3 es el mejor en muchos casos porque el objeto de bloqueo no se expone fuera de su clase.

Si simplemente está compartiendo un contador, considere usar un AtomicInteger u otra clase adecuada del paquete java.util.concurrent.atomic:

public class Test {

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

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

Si es cierto.

Si crea dos instancias de su clase

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

Entonces t1.foo y t2.foo se sincronizan en el mismo objeto estático y, por lo tanto, se bloquean entre sí.

Puede sincronizar su código sobre la clase. Eso sería lo más sencillo.

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

Espero que encuentre útil esta respuesta.

También podemos usar ReentrantLock para lograr la sincronización de variables estáticas.

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