在Java多线程编程中常见的死锁问题实例

原创刺骨的言语ヽ痛彻心扉 2024-12-01 20:00 31阅读 0赞

死锁是多线程并发编程中的一个常见问题。以下是一个简单的Java多线程死锁实例：

```java
// 创建两个互有资源的类
class ResourceA {
    private int count = 10;

public synchronized void acquire() {
        if (count > 0) {
            count--;
            notifyAll();
            System.out.println("Resource A acquired by Thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " cannot acquire Resource A as it's out of stock.");
        }
    }

public synchronized void release() {
        count++;
        notifyAll();
        System.out.println("Resource A released by Thread " + Thread.currentThread().getName());
    }
}

class ResourceB {
    private int count = 10;

public synchronized void acquire() {
        if (count > 0) {
            count--;
            notifyAll();
            System.out.println("Resource B acquired by Thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Thread " + Thread.currentThread().getName() + " cannot acquire Resource B as it's out of stock.");
        }
    }

public synchronized void release() {
        count++;
        notifyAll();
        System.out.println("Resource B released by Thread " + Thread.currentThread().getName());
    }
}

public class DeadLockExample {
    private static ResourceA resourceA = new ResourceA();
    private static ResourceB resourceB = new ResourceB();

public static void main(String[] args) {
        // 创建两个线程，分别尝试获取资源
        Thread thread1 = new Thread(() -> acquireResource(resourceA, resourceB)),"Thread 1");
        Thread thread2 = new Thread(() -> acquireResource(resourceB, resourceA))),"Thread 2");

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private static void acquireResource(ResourceA resourceA, ResourceB resourceB)) {
        // 调用资源获取方法，模拟可能的阻塞情况
        if (resourceA.acquire() && resourceB.acquire()) {
            System.out.println("Both resources acquired successfully by Thread " + Thread.currentThread().getName());
            releaseResources(resourceA, resourceB));
        } else {
            releaseResources(resourceA, resourceB)); // 如果获取资源失败，需要释放之前获取的资源
        }
    }

private static void releaseResources(ResourceA resourceA, ResourceB resourceB)) {
        if (resourceA.release() && resourceB.release()) {
            System.out.println("Both resources released successfully by Thread " + Thread.currentThread().getName());
        } else {
            System.out.println("Failed to release both resources by Thread " + Thread.currentThread().getName()));
        }
    }
}
```

在这个例子中，两个线程分别尝试获取`ResourceA`和`ResourceB`。但是这两个资源是相互依赖的（例如，`ResourceA`需要先被获取才能释放`ResourceB`）。

当线程1获取到`ResourceA`后释放，然后再尝试获取`ResourceB`。然而，此时`ResourceB`已被线程2获取并释放。这就导致了死锁：两个线程互相等待对方释放资源，形成了一个无法打破的循环。