Groovy - 线程死锁

死锁描述了一种情况，即两个或多个线程永远阻塞，互相等待。死锁发生在多个线程需要相同的锁但以不同顺序获取它们时。多线程程序可能会遭受死锁状况，因为 synchronized 关键字会导致执行线程在等待指定对象关联的锁（或监视器）时阻塞。以下是一个示例。

示例 - 演示死锁情况

Example.groovy

class Example {
   static Object Lock1 = new Object();
   static Object Lock2 = new Object();
   
   static void main(String[] args) {
      ThreadDemo1 thread1 = new ThreadDemo1();
      ThreadDemo2 thread2 = new ThreadDemo2();
      thread1.start();
      thread2.start();
   }
   
   private static class ThreadDemo1 extends Thread {
      void run() {
         synchronized (Lock1) {
            println("Thread 1: Holding lock 1...");
            
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            println("Thread 1: Waiting for lock 2...");
            
            synchronized (Lock2) {
               println("Thread 1: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class ThreadDemo2 extends Thread {
      void run() {
         synchronized (Lock2) {
            println("Thread 2: Holding lock 2...");
            
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            println("Thread 2: Waiting for lock 1...");
            
            synchronized (Lock1) {
               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...

上述程序将永远挂起，因为两个线程都无法继续执行，互相等待对方释放锁，因此你可以通过按 CTRL+C 来退出程序。

示例 - 死锁解决方案

让我们改变锁的获取顺序并运行相同的程序，看看两个线程是否仍然会互相等待 −

Example.groovy

class Example {
   static Object Lock1 = new Object();
   static Object Lock2 = new Object();
   
   static void main(String[] args) {
      ThreadDemo1 thread1 = new ThreadDemo1();
      ThreadDemo2 thread2 = new ThreadDemo2();
      thread1.start();
      thread2.start();
   }
   
   private static class ThreadDemo1 extends Thread {
      void run() {
         synchronized (Lock1) {
            println("Thread 1: Holding lock 1...");
            
            try {
               Thread.sleep(10);
            } catch (InterruptedException e) {}
            println("Thread 1: Waiting for lock 2...");
            
            synchronized (Lock2) {
               println("Thread 1: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class ThreadDemo2 extends Thread {
      void run() {
         synchronized (Lock2) {
            println("Thread 2: Holding lock 2...");
           
            try {
               Thread.sleep(10);
            } catch (InterruptedException e) {}
            println("Thread 2: Waiting for lock 1...");
            
            synchronized (Lock1) {
               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...

上述示例仅用于阐明概念，然而，这是一个复杂概念，在开发应用程序以处理死锁情况之前，您应该深入研究它。