静态方法中的同步块将获得 Class 级锁或对象级锁

Question

在下面的代码片段中，我有一个问题。线程将获得 class 级锁或对象级锁 ?

private static Object lock=new Object();
private static Object lock2=new Object();

public static void m1(){
synchronized(lock){
//statements
}
}

public static void m2(){
synchronized(lock2){
//statements
}
}

Answer 1

每个对象都有一个 "monitor"。当您使用同步块时，您指定要同步其监视器的实例。除了同步的块，还有同步的方法。同步的 instance 方法将获取调用该方法的实例的监视器，而同步的 static 方法将获取 java.lang.Class 封闭对象 class.

public class Foo {

  private static final Object STATIC_LOCK = new Object();
  private final Object instanceLock = new Object();

  public static void bar() {
    synchronized (STATIC_LOCK) { // acquires monitor of "STATIC_LOCK" instance
      // guarded code
    }
  }

  public static synchronized void baz() { // acquires monitor of "Foo.class" instance
    // guarded code
  }

  public void qux() {
    synchronized (instanceLock) { // acquires monitor of "instanceLock" instance
      // guarded code
    }
  }

  public synchronized void quux() { // acquires monitor of "this" instance
    // guarded code
  }
}

Answer 2

您已在 synchronized 代码块中明确使用对象 class 实例作为 monitor 对象，这意味着它将锁定那些对象只。

当您将函数定义为 static 和 synchronized 时，代码块使用 Class 本身作为监视对象。因为当您定义静态函数时，该函数属于 class 本身，这意味着您不需要 class 实例来调用此类函数。因此，如果一个静态函数被定义为 synchronized 那么它在多线程环境中的执行将需要锁定所有这些线程中的一些公共监视器对象，在这种情况下就是 class 本身。

Note - Every class definition itself is an instance of java.lang.Class

静态方法中的同步块将获得 Class 级锁或对象级锁

syncronized block inside static method will acquire Class level lock or Object level lock

java

multithreading

synchronized