Java并发编程中死锁案例分析

原创小鱼儿 2024-10-13 09:03 58阅读 0赞

在Java并发编程中，死锁是一种常见的问题。它发生在两个或更多的进程（线程），因争夺资源而造成的一种互相等待的现象，若无外力干涉它们将无法继续执行。

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

```java
// 模拟两个互斥资源的类
class Resource {
    private boolean locked;

public Resource() {
        locked = false;
    }

// 锁定资源（互斥）
    public synchronized void lock() {
        if (locked) {
            throw new IllegalStateException("Resource is already locked");
        }
        locked = true;
    }

// 解锁资源（释放互斥）
    public synchronized void unlock() {
        if (!locked) {
            throw new IllegalStateException("Resource is not locked");
        }
        locked = false;
    }
}

// 进程1，尝试获取资源A和资源B
class Thread1 extends Thread {
    private Resource resourceA, resourceB;

public Thread1(Resource resourceA, Resource resourceB) {
        this.resourceA = resourceA;
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        try {
            // 首先获取资源A
            resourceA.lock();
            System.out.println("Thread 1: Got Resource A");

// 然后尝试获取资源B，但资源A仍锁定状态
            resourceB.lock();
            System.out.println("Thread 1: Got Resource B");

} catch (Exception e) {
            System.err.println("Thread 1: Exception occurred " + e);
        } finally {
            try {
                // 无论是否成功获取资源，都需要解锁资源
                resourceA.unlock();
                resourceB.unlock();

System.out.println("Thread 1: Resources unlocked");

} catch (Exception e) {
                System.err.println("Thread 1: Exception occurred " + e);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resourceA = new Resource();
        Resource resourceB = new Resource();

Thread1 thread1 = new Thread1(resourceA, resourceB));
        thread1.start();
    }
}
```

这个例子中，两个线程`Thread1`都尝试获取资源A和资源B。但是由于锁的互斥性，如果一个资源被锁定，另一个想要获取该资源的线程将会阻塞，直到第一个线程释放资源。

这就产生了死锁：四个进程（线程）相互等待对方释放资源而无法继续执行。