Como sincronizar uma variável estática entre threads executando instâncias diferentes de uma classe em Java?

Eu sei que o uso da synchronizepalavra - chave antes de um método traz sincronização para esse objeto. Ou seja, 2 threads executando a mesma instância do objeto serão sincronizados.

No entanto, como a sincronização está no nível do objeto, 2 threads executando instâncias diferentes do objeto não serão sincronizados. Se tivermos uma variável estática em uma classe Java chamada pelo método, gostaríamos que ela fosse sincronizada entre instâncias da classe. As duas instâncias estão em execução em 2 threads diferentes.

Podemos alcançar a sincronização da seguinte maneira?

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

É verdade que, uma vez que definimos um objeto lockque é estático e estamos usando a palavra-chave synchronizedpara esse bloqueio, a variável estática countagora está sincronizada entre instâncias da classe Test?

Existem várias maneiras de sincronizar o acesso a uma variável estática.

1. Use um método estático sincronizado. Isso sincroniza no objeto de classe.

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

2. Sincronize explicitamente no objeto de classe.

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

3. Sincronize em outro objeto estático.

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

O método 3 é o melhor em muitos casos, porque o objeto de bloqueio não é exposto fora da sua classe.

Se você está simplesmente compartilhando um contador, considere usar um AtomicInteger ou outra classe adequada do pacote java.util.concurrent.atomic:

public class Test {

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

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

Sim, é verdade.

Se você criar duas instâncias da sua classe

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

Então t1.foo e t2.foo são sincronizados no mesmo objeto estático e, portanto, se bloqueiam.

Você pode sincronizar seu código pela classe. Isso seria mais simples.

   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 você encontre esta resposta útil.

Também podemos usar o ReentrantLock para obter a sincronização para variáveis ​​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();
    }  
}