Java进阶者：并发编程中常见死锁问题实例

原创一时失言乱红尘 2024-10-19 09:21 21阅读 0赞

在Java的并发编程中，死锁是一个常见的问题。简单来说，死锁是两个或多个进程在执行过程中因争夺资源而造成的一种相互等待的现象，若无外力干涉，它们都将无法继续执行。

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

```java
// 线程A，需要资源1和2
class ThreadA extends Thread {
    private Resource1 res1;
    private Resource2 res2;

ThreadA(Resource1 res1, Resource2 res2) {
        this.res1 = res1;
        this.res2 = res2;
    }

@Override
    public void run() {
        try {
            while (true) { // 循环获取资源，模拟死锁
                if (res1.acquire()) { // 获取资源1
                    System.out.println("Thread A acquired resource 1");
                    break; // 资源1获取成功，跳出循环
                } else { // 资源1获取失败
                    System.out.println("Thread A failed to acquire resource 1");
                    try {
                        if (res2.acquire()) { // 尝试获取资源2
                            System.out.println("Thread A acquired resource 2");
                            res1.release(); // 资源1释放，进入死锁状态
                            break; // 资源2获取成功，跳出循环
                        } else { // 资源2获取失败，回滚资源1
                            System.out.println("Thread A releasing resource 1 to rollback");
                            res1.release(); // 资源1释放
                        }
                    } catch (Exception e) {
                        System.out.println("Thread A failed to rollback due to exception: " + e.getMessage());
                        break; // 回滚失败，跳出循环
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("Thread A failed during run due to exception: " + e.getMessage());
        }
    }
}

// 线程B，需要资源2和3
class ThreadB extends Thread {
    private Resource2 res2;
    private Resource3 res3;

ThreadB(Resource2 res2, Resource3 res3) {
        this.res2 = res2;
        this.res3 = res3;
    }

@Override
    public void run() {
        try {
            while (true) { // 循环获取资源，模拟死锁
                if (res2.acquire()) { // 获取资源2
                    System.out.println("Thread B acquired resource 2");
                    if (res3.acquire()) { // 尝试获取资源3
                        System.out.println("Thread B acquired resource 3");
                        res2.release(); // 资源2释放，进入死锁状态
                        break; // 资源3获取成功，跳出循环
                    } else { // 资源3获取失败，回滚资源2
                        System.out.println("Thread B releasing resource 2 to rollback");
                        res2.release(); // 资源2释放
                    }
                } else { // 资源2获取失败，回滚资源3
                    System.out.println("Thread B releasing resource 3 to rollback");
                    res3.release(); // 资源3释放
                    try {
                        if (res2.acquire()) { // 再次尝试获取资源2
                            System.out.println("Thread B acquiring resource 2 again after rollback");
                            res3.release(); // 回滚资源3，进入死锁状态
                            break; // 资源2获取成功，跳出循环
                        } else { // 资源2获取失败，回滚资源3并重新尝试获取资源2
                            System.out.println("Thread B releasing resource 3 again to rollback after acquiring resource 2");
                            res3.release(); // 回滚资源3
                            try {
                                if (res2.acquire()) { // 再次尝试获取资源2
                                    System.out.println("Thread B acquired resource 2 again after rollback and retry");
                                    break; // 资源2获取成功，跳出循环
                                } else { // 资源2再次获取失败，回滚资源3并重新开始死锁循环
                                    System.out.println("Thread B releasing resource 3 again to rollback after acquiring resource 2 again");
                                    res3.release(); // 回滚资源3
                                    ThreadB.run();
                                }
                            } catch (Exception e) {
                                System.out.println("Thread B failed during run due to exception: " + e.getMessage());
                                break; // 死循环中失败，跳出循环
                            }
                        }
                    } catch (Exception e) {
                        System.out.println("Thread B failed to acquire resource 2 again after rollback due to exception: " + e.getMessage());
                        try {
                            res3.release(); // 回滚资源3
                        } catch (Exception ex) {
                            System.out.println("Thread B failed to rollback and release resource 3 due to exception during cleanup: " + ex.getMessage());
                        }
                        break; // 死循环中失败，跳出循环
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("Thread B failed during run due to exception: " + e.getMessage());
            break; // 死循环中失败，跳出循环
        }
    }
}

// 创建线程A和线程B实例
Resource1 res1 = new Resource1();
Resource2 res2 = new Resource2();
Resource3 res3 = new Resource3();

ThreadA threadA = new ThreadA(res1, res2));
ThreadB threadB = new ThreadB(res2, res3));

// 启动线程
threadA.start();
threadB.start();
```

在这个例子中，线程A需要资源1和2才能运行，线程B需要资源2和3。当线程B尝试获取资源3时，因为资源2已被线程A占用，所以线程B无法获取资源3，从而陷入死锁状态。