Java并发编程：死锁问题案例分析

原创偏执的太偏执、 2024-09-23 21:15 80阅读 0赞

死锁是多线程编程中的一种严重问题，当两个或更多线程因争夺资源而造成的一种互相等待的现象时，就产生了死锁。

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

```java
// 线程1
class Thread1 extends Thread {
    private Object obj1;
    private Object obj2;

Thread1(Object obj1, Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

@Override
    public void run() {
        synchronized (obj1) {
            try {
                synchronized (obj2) {
                    System.out.println("Thread 1: Acquire obj1 and obj2");
                    // 这里可能会阻塞，需要等待obj2释放
                    }
                } catch (Exception e) {
                    System.out.println("Thread 1: Exception in acquiring obj2");
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread 1: Release obj1");
                synchronized (obj1) {
                    obj1.notifyAll();
                }
            }
        }
    }
}

// 线程2
class Thread2 extends Thread {
    private Object obj3;
    private Object obj4;

Thread2(Object obj3, Object obj4) {
        this.obj3 = obj3;
        this.obj4 = obj4;
    }

@Override
    public void run() {
        synchronized (obj3) {
            try {
                synchronized (obj4) {
                    System.out.println("Thread 2: Acquire obj3 and obj4");
                    // 这里可能会阻塞，需要等待obj4释放
                    }
                } catch (Exception e) {
                    System.out.println("Thread 2: Exception in acquiring obj4");
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread 2: Release obj3");
                synchronized (obj3) {
                    obj3.notifyAll();
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object(), new Object()));
        Thread2 thread2 = new Thread2(new Object(), new Object()));

thread1.start();
        thread2.start();
    }
}
```

在这个例子中，线程1需要获取obj1和obj2，而线程2需要获取obj3和obj4。如果两个线程按照以下顺序交互：

1. 线程1获取obj1
2. 线程2获取obj3
3. 线程1尝试获取obj2（此时obj2被线程2占用）并阻塞
4. 线程2释放obj3，线程1继续执行，成功获取obj2

如果顺序发生变化，例如：

1. 线程1获取obj1
2. 线程2尝试获取obj3（此时obj3被线程1占用）并阻塞
3. 线程1释放obj1，线程2继续执行，成功获取obj3

在这种情况下，就会发生死锁。