多线程并发问题：Java中的DeadLock案例

原创谁借莪１个温暖的怀抱￠ 2024-10-21 15:12 28阅读 0赞

在Java编程中，死锁（Deadlock）是一种常见的多线程并发问题。以下是一个简单的Java DeadLock案例：

假设我们有两个类A和B，它们各自有一个需要阻塞的临界资源操作。

```java
// 类A，操作资源1
public class A {
    private Object resource1 = new Object();

public void acquireResource1() throws InterruptedException {
        while (resource1 != null) { // 需要阻塞直到资源可用
            synchronized (resource1) {
                if (resource1 == this.resource1) {
                    return; // 资源已属于我们，可以离开了
                }
                resource1.wait(); // 释放锁并等待资源被其他线程占用
            }
        }
    }

public void releaseResource1() {
        synchronized (resource1) {
            if (resource1 == this.resource1) {
                resource1.notifyAll(); // 向所有等待资源的线程发出通知
                return;
            }
            resource1 = null; // 释放资源，资源不可再用
        }
    }
}

// 类B，操作资源2
public class B {
    private Object resource2 = new Object();

public void acquireResource2() throws InterruptedException {
        while (resource2 != null) { // 需要阻塞直到资源可用
            synchronized (resource2) {
                if (resource2 == this.resource2) {
                    return; // 资源已属于我们，可以离开了
                }
                resource2.wait(); // 释放锁并等待资源被其他线程占用
            }
        }
    }

public void releaseResource2() {
        synchronized (resource2) {
            if (resource2 == this.resource2) {
                resource2.notifyAll(); // 向所有等待资源的线程发出通知
                return;
            }
            resource2 = null; // 释放资源，资源不可再用
        }
    }
}
```

在这个例子中，类A和B各自有一个需要阻塞的临界资源操作：`resource1` 和 `resource2`。

如果两个类同时获取到了各自需要的资源（如同时请求锁住自己的资源），并且都没有释放资源，那么就会发生死锁。在这种情况下，线程会一直等待，无法继续执行后面的代码。