并发编程中Java的死锁问题实例

原创阳光穿透心脏的1/2处 2024-10-06 08:06 53阅读 0赞

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

```java
// 创建两个线程，分别持有资源A和B
class Resource {
    boolean acquired;

Resource() {
        acquired = false;
    }

void acquire() {
        if (!acquired) {
            acquired = true;
        } else {
            // 如果已有线程占有资源，则无法获取，从而产生死锁
            System.out.println("Deadlock detected. Resources: A, B");
        }
    }

void release() {
        if (acquired) {
            acquired = false;
        } else {
            System.out.println("Resource released unnecessarily.");
        }
    }
}

public class DeadLockExample {
    private Resource resourceA;
    private Resource resourceB;

public DeadLockExample() {
        resourceA = new Resource();
        resourceB = new Resource();
    }

// 两个线程，分别获取资源
    public void startThreads() {
        new Thread(() -> acquireResource(resourceA, "A"))).start();
        new Thread(() -> acquireResource(resourceB, "B"))).start();
    }

private void acquireResource(Resource resource, String占有者) {
        try {
            if (resource.acquire()) {
                System.out.println占有者 + ": Resource A/B acquired.");
                // 具有资源后，可以进行其他操作
                // 在这里，我们简单地让线程继续运行
                // 注意，这并不是推荐的死锁处理策略，而是展示如何使用资源后的逻辑。
                new Thread(() -> doSomethingWith(resource))).start();
            } else {
                System.out.println占有者 + ": Resource acquisition failed.");
            }
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted during resource acquisition.");
            e.printStackTrace();
        }
    }

private void doSomethingWith(Resource resource) {
        // 这里可以实现你的业务逻辑，例如进行计算、通信等
        try {
            Thread.sleep(2000); // 假设需要进行一些耗时操作
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted during business logic.");
            e.printStackTrace();
        }
    }

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        example.startThreads(); // 启动线程
    }
}
```

在这个例子中，两个线程分别请求`resourceA`和`resourceB`。由于资源获取是串行的，当一个线程获得资源后，它会继续运行以执行业务逻辑（这里是一个睡眠2秒的例子）。

如果`resourceA`和`resourceB`之间有某种形式的互锁，那么就会发生死锁。在这个例子中并没有明显的互锁关系，所以不会产生死锁。