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

Question

Sé que usar la palabra clave synchronize antes de que un método proporcione sincronización a ese objeto.
Es decir, 2 hilos que ejecutan la misma instancia del objeto se sincronizarán.
Sin embargo, dado que la sincronización está en el nivel del objeto, 2 hilos que ejecutan instancias diferentes del objeto no se sincronizarán. Entonces, si tenemos una variable estática en una clase java que es llamada por el método, nos gustaría sincronizarla entre 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 ya hemos definido 'bloquear' un objeto que es estático y estamos usando la palabra clave sincronizada para que el bloqueo, el recuento varibale estática se ha sincronizado a través de las instancias de la clase de prueba?

Answer 1

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

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

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

2. sincronizar explícitamente en la clase de objeto.

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

3. Sincronizar en 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++; 
        } 
       } 
   } 
   

Método 3 es la mejor en muchos casos debido a que el objeto de bloqueo no está expuesto fuera de su clase.

Answer 2

Sí, es cierto.

Si crea dos instancias de la clase

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

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

Answer 3

Si sólo va a compartir un contador, considerar el uso de 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(); 
    } 
} 

Answer 4

Si se trata sólo de éste número entero, también se puede utilizar

Interlocked.Increment(count)

(espacio de nombres se System.Threading).

Answer 5

Puede sincronizar su código con la clase. Eso sería más simple.

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 hagas la respuesta útil.