并发编程陷阱：Java多线程中的死锁案例

原创迈不过友情╰ 2024-10-07 03:09 70阅读 0赞

在Java多线程编程中，死锁是一个常见的陷阱。死锁是指两个或更多的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，且每个进程都处于等待状态，无法继续执行。

下面是一个经典的Java多线程死锁案例：

```java
// 线程1拥有资源A
class ResourceA {
    private int count = 0;
    
    public synchronized void acquire() {
        if (count == 0) {
            count++;
            System.out.println("Thread-1: Acquired resource A");
        }
    }

public synchronized void release() {
        if (count > 0) {
            count--;
            System.out.println("Thread-1: Released resource A");
        } else {
            System.out.println("Thread-1: Error in releasing resource A (already released)");
        }
    }
}

// 线程2拥有资源B
class ResourceB {
    private int count = 0;
    
    public synchronized void acquire() {
        if (count == 0) {
            count++;
            System.out.println("Thread-2: Acquired resource B");
        }
    }

public synchronized void release() {
        if (count > 0) {
            count--;
            System.out.println("Thread-2: Released resource B");
        } else {
            System.out.println("Thread-2: Error in releasing resource B (already released)");
        }
    }
}

public class DeadLockExample {
    private final ResourceA resourceA;
    private final ResourceB resourceB;

public DeadLockExample() {
        resourceA = new ResourceA();
        resourceB = new ResourceB();
    }

public void acquireResources() {
        // 线程1先获取资源A
        resourceA.acquire();
        System.out.println("Thread-1: Acquired resource A");

// 然后等待线程2释放资源B
        try {
            resourceB.acquire(); // 等待资源B可用
            System.out.println("Thread-1: Waiting for resource B to be released");
        } catch (InterruptedException e) {
            System.out.println("Thread-1: Interrupted while waiting for resource B");
            Thread.currentThread().interrupt();
        }

// 在等待期间，线程2可能会释放资源B
        if (resourceB.isReleased()) {
            System.out.println("Thread-1: Resource B has been released. Acquiring resource B...");
            resourceB.acquire(); // 现在资源B已经重新被线程1获取
            System.out.println("Thread-1: Acquired resource B");

// 此时，线程2因为等待资源A释放而处于睡眠状态
            // 线程1可以安全地释放资源A，然后唤醒线程2
            resourceA.release();
            System.out.println("Thread-1: Released resource A");

// 同时唤醒线程2
            Thread.currentThread().interrupt(); // 使用中断来唤醒线程2
        }
    }
}
```

在这个例子中，线程1先获取资源A，然后等待线程2释放资源B。如果线程2没有及时释放资源B，线程1会一直等待。这样就形成了死锁。