Java并发编程：锁的使用不当造成的死锁案例

原创骑猪看日落 2024-09-27 01:27 132阅读 0赞

死锁是Java并发编程中一个常见的问题，它发生在两个或更多的线程互相等待对方释放资源时。接下来是一个关于锁的使用不当导致死锁的案例：

```java
// 创建两个互斥资源的类
class ResourceA {
    private int count = 1;
    private Lock lock = new ReentrantLock();

public synchronized void acquire() {
        if (count == 0) {
            lock.lock();
            try {
                count++;
            } finally {
                lock.unlock(); // 释放锁
            }
        }
    }

public synchronized void release() {
        count--;
        if (count == 0) {
            lock.unlock(); // 释放所有锁
        }
    }
}

class ResourceB {
    private int count = 1;
    private Lock lock = new ReentrantLock();

public synchronized void release() {
        count--;
        if (count == 0) {
            lock.unlock(); // 释放所有锁
        }
    }
}

// 创建两个线程，分别尝试获取并使用资源A和资源B
public class DeadLockExample {
    private ResourceA resourceA;
    private ResourceB resourceB;

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

public void acquireResourceA() {
        resourceA.acquire(); // 死锁的形成点
    }

public void acquireResourceB() {
        resourceB.acquire(); // 死锁的形成点
    }

public static void main(String[] args) {
        DeadLockExample deadlockExample = new DeadLockExample();
        Thread thread1 = new Thread(() -> deadlockExample.acquireResourceA()));
        Thread thread2 = new Thread(() -> deadlockExample.acquireResourceB()));

thread1.start(); // 死锁线程1启动
        thread2.start(); // 此时，线程2会等待资源A释放，从而形成死锁

try {
            thread1.join(); // 线程1等待结束
            thread2.join(); // 线程2等待结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，两个类`ResourceA`和`ResourceB`都使用了互斥锁来管理资源。当主线程同时启动获取资源A和资源B的线程时，由于线程间的等待和锁定顺序错误，形成了死锁。

解决这个问题的方法是确保线程按照预期的顺序获取锁，或者使用超时机制避免无限等待。