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

原创ゞ浴缸里的玫瑰 2024-11-27 15:42 6阅读 0赞

在Java并发编程中，死锁是一个常见的问题。死锁通常发生在多个线程相互等待对方释放资源的情况下。

以下是一个简单的Java代码示例，演示了如何产生死锁：

```java
// 定义两个线程，分别请求A和B的资源
class Thread1 extends Thread {
    private Object resourceA;

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

@Override
    public void run() {
        synchronized (resourceA) {  // 请求A的资源
            System.out.println("Thread 1 acquired A.");
            try {
                if (!resourceB.isAvailable()) {  // 假设资源B已由另一个线程占用
                    System.out.println("Thread 1 noticed B occupied.");
                    } else {  // 如果资源B可用，尝试获取
                        synchronized (resourceB) {  // 请求B的资源
                            System.out.println("Thread 1 acquired B.");
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                resourceA.notifyAll();  // 向资源A的所有等待线程发出通知，让他们重新获取资源
                System.out.println("Thread 1 released A and B.");
            }
        }
    }
}

class Thread2 extends Thread {
    private Object resourceB;

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

@Override
    public void run() {
        synchronized (resourceB) {  // 请求B的资源
            System.out.println("Thread 2 acquired B.");
            try {
                if (!resourceA.isAvailable()) {  // 假设资源A已由另一个线程占用
                    System.out.println("Thread 2 noticed A occupied.");
                    } else {  // 如果资源A可用，尝试获取
                        synchronized (resourceA) {  // 请求A的资源
                            System.out.println("Thread 2 acquired A.");
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                resourceB.notifyAll();  // 向资源B的所有等待线程发出通知，让他们重新获取资源
                System.out.println("Thread 2 released B and A.");
            }
        }
    }
}

public class DeadLockExample {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object());  // 创建Thread1对象，请求A资源
        Thread2 thread2 = new Thread2(new Object());  // 创建Thread2对象，请求B资源

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

try {
            // 等待两个线程完成任务
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

这个示例中，Thread1和Thread2分别请求资源A和B。由于它们互斥地获取各自需要的资源（即资源A和资源B），这就导致了死锁的发生。