如何在 Java 中运行类的不同实例的线程之间同步静态变量? [英] How to synchronize a static variable among threads running different instances of a class in Java?

问题描述

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

I know that using the synchronize keyword before a method brings synchronization to that object. That is, 2 threads running the same instance of the object will be synchronized.

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

However, since the synchronization is at the object level, 2 threads running different instances of the object will not be synchronized. If we have a static variable in a Java class that is called by the method, we would like it to be synchronized across instances of the class. The two instances are running in 2 different threads.

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

Can we achieve synchronization in the following way?

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

既然我们已经定义了一个静态对象 lock 并且我们使用关键字 synchronized 作为该锁，静态变量 count<是真的吗?/code> 现在跨类 Test?

Is it true that since we have defined an object lock that is static and we are using the keyword synchronized for that lock, the static variable count is now synchronized across instances of class Test?

推荐答案

有几种方法可以同步对静态变量的访问.

There are several ways to synchronize access to a static variable.

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

1. Use a synchronized static method. This synchronizes on the class object.

public class Test {
    private static int count = 0;

    public static synchronized void incrementCount() {
        count++;
    }
} 

在类对象上显式同步.

Explicitly synchronize on the class object.

public class Test {
    private static int count = 0;

    public void incrementCount() {
        synchronized (Test.class) {
            count++;
        }
    }
} 

同步其他一些静态对象.

Synchronize on some other static object.

public class Test {
    private static int count = 0;
    private static final Object countLock = new Object();

    public void incrementCount() {
        synchronized (countLock) {
            count++;
        }
    }
} 

方法 3 在许多情况下是最好的，因为锁对象不会暴露在您的类之外.

Method 3 is the best in many cases because the lock object is not exposed outside of your class.

这篇关于如何在 Java 中运行类的不同实例的线程之间同步静态变量?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！