Java多线程：死锁问题实例分析

原创旧城等待， 2024-09-14 16:48 122阅读 0赞

死锁在多线程编程中是一种严重的问题。简单来说，当两个或多个线程互相等待对方释放资源时，就可能导致死锁。

以下是一个简单的死锁实例：

```java
// 线程1，拥有资源A
public class ThreadOne extends Thread {
    private Object resourceA;

public ThreadOne(Object resourceA) {
        this.resourceA = resourceA;
    }

@Override
    public void run() {
        synchronized (resourceA) {
            System.out.println("Thread 1 acquire A");
            try {
                // 线程2，等待资源B
                ThreadTwo threadTwo = new ThreadTwo(resourceA);
                threadTwo.start();
                System.out.println("Thread 1 wait for B");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Thread 1 release A");
                synchronized (resourceA) {
                    resourceA.notifyAll();
                }
            }
        }
    }
}

// 线程2，拥有资源B
public class ThreadTwo extends Thread {
    private Object resourceB;

public ThreadTwo(Object resourceB) {
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        synchronized (resourceB) {
            System.out.println("Thread 2 acquire B");
            try {
                // 线程1，等待资源A
                ThreadOne threadOne = new ThreadOne(resourceB);
                threadOne.start();
                System.out.println("Thread 2 wait for A");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Thread 2 release B");
                synchronized (resourceB) {
                    resourceB.notifyAll();
                }
            }
        }
    }
}
```

在这个例子中，线程1持有资源A，等待资源B。线程2持有资源B，等待资源A。

如果按照正常顺序执行，线程1先释放A，然后等待B（线程2会释放B）。线程2先释放B，然后等待A（线程1会释放A）。

但问题在于，如果线程2在获取B之前被阻塞，那么它将无法释放B。同样的，如果线程1在获取A之前被阻塞，那么它也将无法释放A。

这就导致了死锁：两个或多个线程互相等待对方释放资源，而这种状态无法打破，从而陷入僵局。