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

原创水深无声 2024-10-16 18:48 97阅读 0赞

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

以下是一个经典的死锁案例：

```java
// 线程1（主）：
class Thread1 extends Thread {
    Object resource1 = new Object();
    Object resource2 = new Object();

public void run() {
        try {
            acquireResource(resource1);
            acquireResource(resource2);

// 主线程执行完操作后释放资源
            releaseResource(resource1);
            releaseResource(resource2);

} catch (InterruptedException | RuntimeException e) {
            System.out.println("Thread 1: Error " + e.getMessage());
            e.printStackTrace();
        }
    }

// 获取资源方法
    private synchronized void acquireResource(Object resource) {
        while (!resourceLocks.contains(resource)) {
            try {
                // 线程等待资源可用
                lock资源共享资源(resource);
                resourceLocks.add(resource);
                System.out.println("Thread 1: Resource " + resource + " acquired");

} catch (InterruptedException | RuntimeException e) {
                System.out.println("Thread 1: Error " + e.getMessage());
                e.printStackTrace();
                unlockResource(resource);
            }
        }
    }

// 释放资源方法
    private synchronized void releaseResource(Object resource) {
        if (resourceLocks.contains(resource)) {
            resourceLocks.remove(resource);
            try {
                // 线程解锁，资源返回可用状态
                unlockResource(resource);
                System.out.println("Thread 1: Resource " + resource + " released");

} catch (InterruptedException | RuntimeException e) {
                System.out.println("Thread 1: Error " + e.getMessage());
                e.printStackTrace();
            }
        }
    }

public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();
    }
}
```

在这个例子中，线程1（主线程）有两个资源：resource1 和 resource2。每个线程需要获取这两个资源才能继续执行。

当主线上线程1尝试获取资源时，可能会出现以下几种情况导致死锁：

1. 线程1先获取resource1，然后试图获取resource2。
2. 在线程1获取resource2后，尝试释放resource1，但此时resource1已经被主线程2占用。
3. 由于线程间的相互等待，循环执行直到资源耗尽。

为了避免这种情况，可以采用超时机制、死锁检测算法（如银行家算法）等方法来解决多线程并发中的死锁问题。