Java 如何解决Java线程死锁异常（ThreadDeadlockException）

在本文中，我们将介绍Java中线程死锁异常的概念以及如何解决它。线程死锁是多线程编程中常见的问题，当两个或多个线程彼此持有对方所需的资源而无法继续执行时，就会发生死锁。

阅读更多：Java 教程

什么是线程死锁？

线程死锁是一种多线程并发操作中的常见问题，它发生在两个或多个线程等待并且无法获取对方所需的资源时。当线程A持有资源1并等待资源2，而线程B持有资源2并等待资源1时，就会发生死锁。此时，两个线程都无法继续执行，程序会陷入死锁状态。

以下是一个简单的死锁示例，用两个线程和两个互斥锁来模拟：

public class DeadlockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock 1...");
                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 1 and 2...");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

上述代码中，我们创建了两个线程，每个线程都依次获取两个互斥锁。因为线程1获取到lock1后需要lock2，而线程2获取到lock2后需要lock1，所以两个线程会相互等待对方所持有的锁，从而导致死锁。

如何解决线程死锁？

虽然线程死锁是个严重的问题，但是我们可以采取一些策略来避免和解决它。

1. 避免锁的循环等待

死锁最基本的原因之一是锁的循环等待。为了避免线程死锁，我们应该尽量避免循环等待的情况。

2. 按顺序获取锁

通过按照固定的顺序来获取锁，可以减少产生死锁的可能性。确保线程按照相同的顺序获取锁，可以防止死锁的产生。

以下是采用按顺序获取锁的修改后的示例代码：

public class DeadlockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock1) { // 锁的获取顺序改变
                System.out.println("Thread 2: Holding lock 1..."); 
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread 2: Holding lock 1 and 2...");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

通过修改线程2获取锁的顺序，使得两个线程按照相同的顺序获取锁，我们可以避免死锁。

3. 使用定时等待

如果在一定的时间内无法获取到锁，可以放弃当前的锁获取尝试，避免线程长时间等待而导致死锁。这可以通过tryLock()方法来实现。

以下是使用定时等待解决死锁的示例代码：

public class DeadlockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for lock 2...");
                if (Thread.holdsLock(lock2)) {
                    System.out.println("Thread 1: Cannot obtain lock 2, releasing lock1...");
                    return;
                }
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 and 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for lock 1...");
                if (Thread.holdsLock(lock1)) { // 判断线程是否获取到锁
                    System.out.println("Thread 2: Cannot obtain lock 1, releasing lock2...");
                    return;
                }
                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 1 and 2...");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

通过使用Thread.holdsLock()方法来判断线程是否成功获取到锁，如果没有获取到，可以选择放弃当前的锁获取尝试，从而避免死锁。