Java多线程并发编程：死锁问题案例分析

原创清疚 2024-12-04 09:39 36阅读 0赞

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

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

```java
// 线程A和B共享资源R1和R2
public class DeadlockExample {
    private Object resourceR1 = new Object();
    private Object resourceR2 = new Object();

// 线程A，负责获取资源R1和R2
    public void threadA() {
        while (true) {  // 模拟线程A的无限循环行为
            synchronized (resourceR1) {
                if (resourceR1 != null) {
                    synchronized (resourceR2) {
                        // 这里假设获取资源是顺序执行的
                        resourceR1 = null;  // 将资源R1归还
                        resourceR2 = null;  // 将资源R2归还

// 线程A成功获取资源后，可以退出循环
                        break;
                    }
                } else {
                    // 若资源R1为空，则等待其被其他线程归还
                    synchronized (resourceR1) {
                        try {
                            resourceR1 = null;  // 将资源R1设置为null
                            Thread.sleep(500);  // 线程A模拟等待资源R1归还的时间
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

// 线程B，负责获取资源R1和R2
    public void threadB() {
        while (true) {  // 模拟线程B的无限循环行为
            synchronized (resourceR2) {
                if (resourceR2 != null) {
                    synchronized (resourceR1) {
                        // 这里假设获取资源是顺序执行的
                        resourceR2 = null;  // 将资源R2归还
                        resourceR1 = null;  // 将资源R1归还

// 线程B成功获取资源后，可以退出循环
                        break;
                    }
                } else {
                    // 若资源R2为空，则等待其被其他线程归还
                    synchronized (resourceR2) {
                        try {
                            resourceR2 = null;  // 将资源R2设置为null
                            Thread.sleep(500);  // 线程B模拟等待资源R2归还的时间
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread threadA = new Thread(example::threadA));
        Thread threadB = new Thread(example::threadB));

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

// 线程A和线程B会相互等待对方释放资源，从而造成死锁
    }
}
```

在这个例子中，线程A需要获取资源R1和R2，而线程B也需要获取这些资源。由于两者都需要对方已经获取的资源才能继续执行，所以它们就会陷入互相等待的局面，形成了典型的死锁现象。