如何在Java中运行类的不同实例的线程之间同步静态变量？

我知道synchronize在方法带来同步到该对象之前使用关键字。也就是说，运行对象的同一实例的2个线程将被同步。

但是，由于同步是在对象级别进行的，因此运行对象的不同实例的2个线程将不会同步。如果在Java类中有一个由该方法调用的静态变量，则希望在类的各个实例之间进行同步。这两个实例在2个不同的线程中运行。

我们可以通过以下方式实现同​​步吗？

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

确实如此，因为我们已经定义了一个lock静态对象，并且正在使用该synchronized锁的关键字，所以static变量count现在可以在class实例之间进行同步Test？

有几种同步对静态变量的访问的方法。

1. 使用同步静态方法。这将在类对象上同步。

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

2. 在类对象上显式同步。

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

3. 在其他静态对象上同步。

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

在很多情况下，方法3是最好的，因为锁对象没有暴露在类之外。

如果您只是共享一个计数器，请考虑使用AtomicInteger或java.util.concurrent.atomic包中的另一个合适的类：

public class Test {

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

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

是的，它是真的。

如果您创建类的两个实例

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

然后，t1.foo和t2.foo都在同一个静态对象上同步，因此彼此阻塞。

您可以在类上同步代码。那将是最简单的。

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

希望您觉得这个答案有用。

我们还可以使用ReentrantLock实现静态变量的同步。

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