Java多线程问题：死锁案例与解决方案

原创今天药忘吃喽~ 2024-10-06 15:57 49阅读 0赞

死锁是多线程编程中的一种严重问题。当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

以下是一个简单的死锁案例：

```java
// 线程A需要资源1和2
class A implements Runnable {
    int res1 = 0, res2 = 0;

public void run() {
        synchronized (res1) {
            synchronized (res2) {
                // 先获取资源1，等待资源2释放
                res1.set(1);
                while (!res2.isSet(1))) {
                    // 等待资源2释放，但无法继续获取资源
                    System.out.println("线程A等待资源2释放...");
                    try {
                        Thread.sleep(1000); // 暂停1秒，以模拟等待过程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

// 现在可以获取资源2了
                System.out.println("线程A获取资源2...");
                res2.set(1);

// 完成资源的获取和释放
                System.out.println("线程A完成任务...");
            }
        }
    }
}

// 线程B需要资源2和3
class B implements Runnable {
    int res2 = 0, res3 = 0;

public void run() {
        synchronized (res2) {
            synchronized (res3) {
                // 先获取资源2，等待资源3释放
                System.out.println("线程B获取资源2...");
                res2.set(1);

while (!res3.isSet(1))) {
                    // 等待资源3释放，但无法继续获取资源
                    System.out.println("线程B等待资源3释放...");
                    try {
                        Thread.sleep(1000); // 暂停1秒，以模拟等待过程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

// 现在可以获取资源3了
                System.out.println("线程B获取资源3...");
                res3.set(1);

// 完成资源的获取和释放
                System.out.println("线程B完成任务...");
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程A和线程B
        Thread threadA = new Thread(new A()));
        Thread threadB = new Thread(new B()));

// 启动线程A和线程B
        threadA.start();
        threadB.start();

// 等待所有线程完成任务
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在上述代码中，线程A需要资源1（设置为1）和2（设置为0），而线程B则需要资源2（设置为1）和3（设置为0）。两线程互等等待对方释放资源。

当线程A获取到资源2后，它无法立即继续获取资源3。同样的情况发生在线程B获取资源3时。

这种情况下，如果设计者没有采取适当的预防措施，比如在获取资源之前检查资源状态或设定超时机制，就会导致死锁的出现。