使用Java并发时的死锁问题实例

原创分手后的思念是犯贱 2024-09-27 08:48 62阅读 0赞

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

```java
// 创建两个线程，分别持有资源A和B
class Thread1 extends Thread {
    private Object resourceA;

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

@Override
    public void run() {
        try {
            synchronized (resourceA) { // 获取资源A
                if (resourceA != null) { // 如果资源有效，释放A并获取B
                    System.out.println("Thread1 released A and got B.");
                    synchronized (resourceB) { // 获得资源B
                        resourceA = null; // 释放资源A
                        Thread2.start(); // 启动等待A的线程2
                    }
                } else {
                    throw new RuntimeException("Resource A is invalid!");
                }
            }
        } catch (Exception e) {
            System.out.println("Thread1 caught exception: " + e);
        }
    }

Object getResourceA() {
        return resourceA;
    }
}

class Thread2 extends Thread {
    private Object resourceB;

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

@Override
    public void run() {
        try {
            synchronized (resourceB) { // 获得资源B
                if (resourceB != null) { // 如果资源有效，释放B并启动等待A的线程1
                    System.out.println("Thread2 released B and started Thread1.");
                    Thread1.start(); // 启动等待B的线程1
                    resourceB = null; // 释放资源B
                } else {
                    throw new RuntimeException("Resource B is invalid!");
                }
            }
        } catch (Exception e) {
            System.out.println("Thread2 caught exception: " + e);
        }
    }

Object getResourceB() {
        return resourceB;
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object()); // 创建线程1，初始资源为Object
        Thread2 thread2 = new Thread2(new Object()); // 创建线程2，初始资源为Object

thread1.start(); // 启动线程1
        thread2.start(); // 同时启动线程2

// 这里应该是一个无限循环，用于检查死锁情况
        while (true) {
            try {
                Thread.sleep(500); // 暂停500毫秒，便于观察
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

在这个例子中，线程1持有资源A，线程2持有资源B。如果线程2先启动并获取A（这会导致A被释放），然后等待A，而线程1在此期间启动并获取B（这会导致B被释放），接着获取A。这时，两个线程都会阻塞，形成死锁。

为了避免这种情况，通常需要满足以下条件之一：

- 当前资源的请求者在获取资源之前必须先获得对这些资源的控制权。
- 系统必须保证无循环等待资源的情况发生。

在上述代码中，如果适当修改线程的执行顺序或添加适当的同步机制，就可以避免死锁。但这超出了这个简单示例的范围。