我是多线程的新手，我遇到了这个例子:

public class TestThread {
   public static Object Lock1 = new Object();
   public static Object Lock2 = new Object();

   public static void main(String args[]) {

      ThreadDemo1 T1 = new ThreadDemo1();
      ThreadDemo2 T2 = new ThreadDemo2();
      T1.start();
      T2.start();
   }

   private static class ThreadDemo1 extends Thread {
      public void run() {
         synchronized (Lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (Lock2) {
               System.out.println("Thread 1: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class ThreadDemo2 extends Thread {
      public void run() {
         synchronized (Lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 1...");
            synchronized (Lock1) {
               System.out.println("Thread 2: Holding lock 1 & 2...");
            }
         }
      }
   } 
}

这会导致以下示例输出:

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...

即，存在死锁。但是，如果我们改变在第二个线程中获得锁的顺序，现在看起来像这样:

public class TestThread {
   public static Object Lock1 = new Object();
   public static Object Lock2 = new Object();

   public static void main(String args[]) {

      ThreadDemo1 T1 = new ThreadDemo1();
      ThreadDemo2 T2 = new ThreadDemo2();
      T1.start();
      T2.start();
   }

   private static class ThreadDemo1 extends Thread {
      public void run() {
         synchronized (Lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (Lock2) {
               System.out.println("Thread 1: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class ThreadDemo2 extends Thread {
      public void run() {
         synchronized (Lock1) {
            System.out.println("Thread 2: Holding lock 1...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 2...");
            synchronized (Lock2) {
               System.out.println("Thread 2: Holding lock 1 & 2...");
            }
         }
      }
   } 
}

它按预期工作，示例输出如下所示:

Thread 1: Holding lock 1...
Thread 1: Waiting for lock 2...
Thread 1: Holding lock 1 & 2...
Thread 2: Holding lock 1...
Thread 2: Waiting for lock 2...
Thread 2: Holding lock 1 & 2...

有人可以向我解释导致死锁的第一个代码中发生了什么，为什么第二个代码中的更改可以修复它？

最佳答案

这是第一种情况的可能情况:

线程 1 获取 Lock1 并进入 hibernate 状态 10 毫秒。现在线程 2 获取了 Lock2 并进入 hibernate 状态 10 毫秒。

现在Thread 1 试图获取Lock2，但是由于被Thread 2 获取而无法获取，而Thread 2 试图获取被Thread 锁定的Lock1 1.

在第二种情况下，我们假设第一个线程被选中运行。它获得 Lock1，而另一个线程被阻塞，因为它也试图获得 Lock1。现在线程 1 进入休眠状态，并继续执行第二个(嵌套的)同步块(synchronized block)。它试图获得它(因为它仍然是免费的)——现在他得到了 2 锁。另一个线程仍然被阻塞。

只有在它完成执行后，它才会释放两个锁(因为它退出了同步块(synchronized block))，现在 JVM 可以自由决定选择哪个线程，但这并不重要，发生相同的逻辑。

关于java - 了解为什么在此实现中会发生死锁，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36833696/