Java并发编程：死锁现象案例分析

原创男娘i 2024-12-08 17:24 25阅读 0赞

死锁是多线程编程中的一种严重问题。当两个或更多的线程因争夺资源而造成的一种互相等待的现象时，就可能发生死锁。

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

```java
// 线程A
class A implements Runnable {
    private Object resourceA;

A(Object resourceA) {
        this.resourceA = resourceA;
    }

@Override
    public void run() {
        try {
            lock(resourceA); // 获取资源A的锁
            lock(resourceB); // 获取资源B的锁

// 线程A需要资源A和资源B，而这两样资源都被线程A锁定在手。所以，此时的线程A陷入了死循环。

unlock(resourceA);
            unlock(resourceB);

} catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private synchronized void lock(Object resource) {
        if (resource == resourceA) {
            this.lockedResource = resource;
        } else if (resource == resourceB) {
            // 同理
        } else {
            throw new IllegalArgumentException("Invalid resource: " + resource);
        }

this.locked = true;
    }

private synchronized void unlock(Object resource) {
        if (resource == lockedResource && locked) {
            this.lockedResource = null;
            this.locked = false;

// 如果两个锁都被释放，那么可以认为死锁已经被解除。
            if (resource == resourceA && resource == resourceB)) {
                System.out.println("Deadlock resolved");
            }
        } else {
            throw new IllegalArgumentException("Invalid resource: " + resource);
        }
    }
}

// 线程B
class B implements Runnable {
    private Object resourceB;

B(Object resourceB) {
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        try {
            lock(resourceB); // 获取资源B的锁

lock(resourceA); // 获取资源A的锁

// 线程B需要资源A和资源B，而这两样资源都被线程B锁定在手。所以，此时的线程B也陷入了死循环。

unlock(resourceB);
            unlock(resourceA);

} catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private synchronized void lock(Object resource) {
        if (resource == resourceB) {
            this.lockedResource = resource;
        } else if (resource == resourceA) {
            // 同理
        } else {
            throw new IllegalArgumentException("Invalid resource: " + resource);
        }

this.locked = true;
    }

private synchronized void unlock(Object resource) {
        if (resource == lockedResource && locked) {
            this.lockedResource = null;
            this.locked = false;

在这个例子中，线程A需要资源A和资源B，线程B需要资源B和资源A。两个线程都各自获得了对方需要的资源并开始执行。

由于每个线程都在等待对方释放资源，导致了两个线程都无法继续执行，从而形成了死锁。