同步静态方法

Question

我正在编写的代码需要在几个静态方法之间进行一些同步。我的目标是阻止执行这些方法中的任何一个，如果其中一个执行。例如：

public class Foo{

       static Object lock = new Object();
       static List<SomeObject> listOfObjects = new ArrayList<>() ;


       public static void methodA() {
              synchronized (lock) {
                  //Do some stuff
                    methodB();
              }
       }

       public static List<SomeObject> methodB() {
              synchronized (lock) {
                  //Do some stuff
                   return listOfObjects;
              }
       }

}

现在让我们假设下面的代码是从代码中的某个地方执行的:

Foo.methodA();
Foo.methodB();

我的问题是:

>

它实际上是同步的吗？methodA和methodB不会同时运行吗？

如果是，methodA调用methodB会不会造成死锁？

Answer 1

不。方法 A 和方法 B 将同时运行，因为同步的不是方法，而是内部的代码。代码将正常继续与具有锁定的任何人一起使用。然后另一种方法将完成。

    public class Foo1 {

       static Object        lock          = new Object();
       static List<Integer> listOfObjects = new ArrayList<>();

       public static void main(String[] args) {
          new Foo1().start();
       }
       public void start() {
          new Thread(() -> methodA()).start();
          // method A has the lock
          sleep(1000); // sleep 1 second
          // but method B is still entered and prints first
          new Thread(() -> methodB()).start();
       }
       public static void methodA() {
          sleep(5000); // sleep 5 seconds
          System.out.println("Entering methodA()");
          synchronized (lock) {
             // Do some stuff
             methodB();
          }
       }

       public static List<Integer> methodB() {
          System.out.println("Entering methodB()");
          synchronized (lock) {
             // Do some stuff
             return listOfObjects;
          }
       }

       static void sleep(int milli) {
          try {
             Thread.sleep(milli);
          }
          catch (InterruptedException ie) {
          }
       }

    }

Answer 2

它实际上是同步的吗？方法 A 和方法 B 不会同时运行吗？

是的，这个同步看起来不错。< br >一个线程可以多次获取同一个锁，从而增加锁计数器。在它释放所有这些锁之后，只有另一个线程才能获得那个锁。在您的代码中，调用< code>methodA()的线程获取< code>lock两次，一次在< code>methodA()中，另一次在< code>methodB()中。然后它释放它们两次(当同步块结束时)。

如果是，methodA调用methodB会不会造成死锁？

不，如上所述，它不会造成死锁，除非您在这些方法中执行一些可能需要永远才能完成的操作，在这种情况下，将会出现饥饿。如果您没有执行任何此类操作，那么我认为当您仅使用一个锁时，您不会陷入死锁。

Answer 3

答案：

1. "它实际上是同步的吗？方法A和方法B不会同时运行吗？"-是的，这些方法是同步的。更准确地说，方法中的代码块是同步的。
2. "如果是这样，方法A调用方法B会创建死锁吗？"-不，同步关键字本质上是可重入的，这意味着如果一个同步方法调用另一个需要相同锁的同步方法，那么当前持有锁的线程可以进入该方法而无需获取锁"-from 1

您可以通过提供私有关键字和最终关键字来稍微改进代码：

private static final Object lock = new Object();

另外，不要返回对要保护的< code>List的直接引用。返回< code >只读视图:

return Collections.unmodifiableList(listOfObjects);

从现在开始，客户端只有只读访问权限，这可以保护您免受许多意外情况的影响。

1. 同步块中的静态与非静态锁定对象
2. Java中的对象级锁与类级锁