类的静态方法之间的同步

Question

我编写了以下代码：

public class ClassAndObjectLock {
 public static void main(String[] args) {
  new Thread(new EvenThread()).start();
  new Thread(new OddThread()).start();
 }
}

class EvenThread implements Runnable {
 public void run() {
  for (int i = 0; i < 10; i += 2) {
   CommonClass.printEvenNumber(i);
  }
 }
}

class OddThread implements Runnable {
 public void run() {
  for (int i = 1; i < 10; i += 2) {
   CommonClass.printOddNumber(i);
  }
 }
}

class CommonClass {
 public static void printEvenNumber(int num) {
  synchronized (CommonClass.class) {
   System.out.println("Even :" + num);
  }
 }

 public static void printOddNumber(int num) {
  synchronized (CommonClass.class) {
   System.out.println("Odd :" + num);
  }
 }
}

当我执行上述代码时，输​​出如下：

Even :0
Odd :1
Even :2
Odd :3
Even :4
Odd :5
Even :6
Odd :7
Even :8
Odd :9

我不明白这个输出。根据我的理解，当执行 new Thread(new EvenThread()).start(); 时，它会生成一个 EvenThread 类的线程，该线程应该获取 EvenThread 的锁code>CommonClass 并保持自身锁定，直到打印出所有偶数值。只有在 EvenThread 对象完成后，OddThread 对象才应该获得机会。因此，在我看来，输出应该如下：

Even :0  
Even :2
Even :4
Even :6
Even :8
Odd :1
Odd :3
Odd :5
Odd :7
Odd :9

谁能解释一下底层逻辑吗？

Answer 1

根据我的理解，当 new Thread(new EvenThread()).start();执行时，它会生成一个 EvenThread 类的线程，该线程应该获取 CommonClass 的锁并保持该锁，直到它打印所有偶数值。

不，事实并非如此：

 public static void printOddNumber(int num) {
   synchronized (CommonClass.class) {
       System.out.println("Odd :" + num);
   }
 }

哪个（因为该方法在监视器类上是静态的），也可以写为

 public static synchronized void printOddNumber(int num) {
       System.out.println("Odd :" + num);
 }

查看同步块的范围：它仅打印一个数字，然后释放锁。

如果您想在不被中断的情况下打印所有数字，则必须在整个 for 循环期间锁定：

public void run() {
  synchronized(CommonClass.class){
    for (int i = 0; i < 10; i += 2) {
     System.out.println("Even :" + num);
    }
  }
}

Answer 2

您的同步是在打印方法级别，这意味着每次打印都会获取和释放锁。如果您希望线程在持续时间内保持锁定，则必须在线程的 run 方法中同步该对象（在循环周围）。