死锁描述了两个或多个线程等待彼此而被永久阻塞的情况。 当多个线程需要相同的锁定但以不同的顺序获取时，会发生死锁。 java多线程程序可能会遇到死锁状况，因为synchronized关键字会导致执行线程在等待与指定对象相关联的锁定或监视时出现阻止情况。 看看下面一个例子。

示例

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...

上述程序将永久挂起，因为两个线程都不能继续进行，等待彼此释放锁定，所以您可以按ctrl + c退出程序。

死锁解决方案示例

下面我们修改锁的顺序并运行相同的程序，看看这两个线程是否仍然相互等待 -

实例

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...

上面的例子只是为了更容易理解这个解决死锁的概念，然而，这是一个复杂的概念，应该深入了解它，然后才能再开发应用程序来处理死锁情况。