Java并发问题：死锁示例

原创迈不过友情╰ 2024-10-05 21:03 73阅读 0赞

死锁是多线程编程中的一种严重问题，当两个或更多的线程互相等待对方释放资源时，就会形成死锁。

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

```java
// 创建两个线程，每个线程都需要对方释放资源
class DeadLockThread1 extends Thread {
    private Object resource1 = new Object();

public DeadLockThread1(String name) {
        super(name);
    }

@Override
    public void run() {
        synchronized (resource1) { // 线程1等待资源1的释放
            try {
                System.out.println("Thread 1 waiting for Thread 2 to release resource1...");

// 这里模拟线程2需要资源2，但无法获取资源2的情况
                Object resource2 = new Object();
                synchronized (resource2) { // 线程2等待资源2的释放
                    System.out.println("Thread 2 waiting for Thread 1 to release resource2...");

// 当线程1释放资源1后，线程1可以获取资源2并释放资源2
                    resource1 = null;
                    resource2 = null;

System.out.println("Both threads have released resources. No deadlock!");

} catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally { // 确保无论是否达到预期结果，都释放资源
                resource1 = null;
                resource2 = null;
            }
        }
    }
}

class DeadLockThread2 extends Thread {
    private Object resource2 = new Object();

public DeadLockThread2(String name) {
        super(name);
    }

@Override
    public void run() {
        synchronized (resource2) { // 线程2等待资源2的释放
            try {
                System.out.println("Thread 2 waiting for Thread 1 to release resource2...");

// 当线程1释放资源1后，线程1可以获取资源2并释放资源2
                Object resource1 = new Object();
                synchronized (resource1) { // 线程1等待资源1的释放
                    System.out.println("Thread 1 waiting for Thread 2 to release resource1...");

// 当线程2释放资源2后，线程2可以获取资源1并释放资源1
                    resource2 = null;
                    resource1 = null;

System.out.println("Both threads have released resources. No deadlock!");

// 启动两个线程，它们相互等待对方释放资源
new DeadLockThread1("Thread 1").start();
new DeadLockThread2("Thread 2").start();
```

在这个示例中，线程1需要资源1的释放才能获取资源2并释放资源2。同样，线程2也需要资源2的释放才能获取资源1并释放资源1。这两个线程互相等待对方释放资源，形成了死锁。