【JavaSE专栏79】线程死锁，多个线程被阻塞，等待彼此持有的资源

Designer 小郑

发布于 2023-08-18 08:49:39

5320

发布于 2023-08-18 08:49:39

文章被收录于专栏：跟着小郑学JAVA

本文讲解了 Java 中线程死锁的语法和应用场景，并给出了样例代码。线程死锁是指在多线程编程中，两个或多个线程被永久地阻塞，等待彼此持有的资源，而无法继续执行下去。

一、什么是线程死锁

线程死锁是指在多线程编程中，两个或多个线程被永久地阻塞，等待彼此持有的资源，而无法继续执行下去，这种情况下，被阻塞的线程将无法释放它所持有的资源，导致所有的线程都无法继续工作。

线程死锁通常发生在多个线程同时试图获取共享资源的情况下，而每个线程都在等待其他线程释放它所需要的资源。这种情况下，没有任何一个线程能够继续执行下去，形成了死锁。

线程死锁的产生通常需要满足以下

个条件，称为死锁的必要条件，请同学们认真学习。

互斥条件：至少有一个资源被且只能被一个线程持有。
请求与保持条件：一个线程在持有资源的同时又请求其他线程持有的资源。
不可剥夺条件：已经分配给一个线程的资源不能被其他线程强制性地抢占。
循环等待条件：存在一个线程的资源请求序列，使得每个线程都在等待下一个线程所持有的资源。

要避免线程死锁，可以采取一些预防措施，如避免循环等待、确保资源的合理分配和释放、使用加锁机制来保证互斥等，此外还可以使用死锁检测和死锁恢复机制来解决线程死锁问题。

二、线程死锁的产生原因

线程死锁的产生原因通常是由于多个线程之间竞争共享资源时出现的一系列问题，以下是几种常见的线程死锁的产生原因，请同学们认真学习。

竞争资源：多个线程同时竞争有限的资源，当每个线程都持有部分资源并且等待其他线程释放它需要的资源时，就会发生死锁。
循环等待：多个线程之间形成循环依赖，每个线程都在等待其他线程所持有的资源，导致循环等待的状态。
独占资源无法释放：一个线程持有某个资源并且不释放，而其他线程需要该资源时无法继续执行，最终导致死锁。
加锁顺序不一致：多个线程按照不同的顺序请求资源和释放资源，导致出现资源竞争的情况，可能引发死锁。
阻塞、等待或者睡眠：线程在等待某个操作完成或者等待其他线程的通知时，如果等待的时间过长，可能导致其他线程无法继续执行，最终导致死锁。

为了避免线程死锁的发生，需要合理设计和管理线程的竞争和资源的分配，确保资源的合理使用和释放，避免循环依赖和死锁的条件。同时，可以使用死锁检测和死锁恢复机制来解决死锁问题。

三、线程死锁的模拟

下面是一个使用 Java 语言模拟线程死锁的样例代码，请同学们复制到本地执行。

public class ThreadDeadlock {
    public static void main(String[] args) {
        final Object resource1 = new Object();
        final Object resource2 = new Object();
        
        // 线程1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1");
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                synchronized (resource2) {
                    System.out.println("Thread 1: Holding resource 1 & 2");
                }
            }
        });
        
        // 线程2
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2");
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                synchronized (resource1) {
                    System.out.println("Thread 2: Holding resource 2 & 1");
                }
            }
        });
        
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

在上述代码中，有两个线程 thread1 和 thread2，它们都试图获取两个资源 resource1 和 resource2。然而，线程

首先获取了 resource1，然后试图获取 resource2；而线程

首先获取了 resource2，然后试图获取 resource1，由于两个线程都在等待对方释放所需要的资源，因此会造成死锁的情况。

四、线程死锁的应用场景

线程死锁是一个不可避免的问题，它可能发生在任何多线程应用程序中的特定条件下。以下是一些常见的线程死锁的应用场景，请同学们认真学习。

资源竞争：当多个线程同时竞争有限的资源时，例如数据库连接池、文件系统、网络资源等，如果处理不当，可能会导致线程死锁。
锁的嵌套使用：当多个线程按不同的顺序请求锁时，如果锁的嵌套使用不当，可能会导致发生死锁。
线程间的相互依赖：当多个线程之间存在依赖关系，需要等待其他线程释放资源时，如果依赖关系不正确或者线程等待时间过长，可能会导致死锁。
死锁的传播：当一个线程发生死锁，它可能会导致其他线程也被阻塞，从而形成死锁链。
死锁的循环等待：当多个线程发生循环等待的情况，每个线程都在等待其他线程所持有的资源时，可能会导致发生死锁。

虽然线程死锁是一个常见的多线程编程问题，但并非所有的多线程应用程序都会发生死锁，正确设计和管理线程之间的资源竞争、避免循环依赖、合理分配和释放资源等措施可以降低死锁的发生概率。

五、线程死锁面试题

问题

请说明什么是线程死锁？并举一个实例来解释。

回答

线程死锁是指两个或多个线程彼此持有对方所需的资源，而无法继续执行的状态。在这种情况下，每个线程都在等待其他线程释放它所需要的资源，导致所有线程无法继续执行下去，形成了死锁。

实例

假设有两个线程 A AA 和 B BB，每个线程都需要获取对方持有的资源才能继续执行。线程 A AA 持有资源 X XX，但需要资源 Y YY 才能继续执行；线程 B BB 持有资源 Y YY，但需要资源 X XX 才能继续执行。因此，线程 A AA 等待线程 B BB 释放资源 Y YY，而线程 B BB 等待线程 A AA 释放资源 X XX，由于两个线程都无法继续执行，它们进入了死锁状态。

代码示例

public class ThreadDeadlock {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        // 线程1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 1: Holding resource 1 and 2.");
                }
            }
        });

        // 线程2
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("Thread 2: Holding resource 1 and 2.");
                }
            }
        });

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

在上述代码中，线程 1 11 持有资源 1 11 并等待资源 2 22，而线程 2 22 持有资源 2 22 并等待资源 1 11。因此，当两个线程同时执行时，它们会相互等待对方释放所需的资源，导致线程死锁。