Java多线程问题：死锁实例

原创男娘i 2024-09-11 12:18 115阅读 0赞

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

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

```java
// 创建两个线程A和B
class ThreadA extends Thread {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void run() {
        synchronized (lock1) {
            try {
                System.out.println("Thread A acquire lock1");
                // 等待锁2可用
                synchronized (lock2) {
                    System.out.println("Thread A acquire lock2");
                    // 释放锁1，让线程B获取
                    lock1.notify();
                    // 再等待锁2释放，再次获取锁2
                    lock2.wait();
                    System.out.println("Thread A release lock2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread A release lock1");
            }
        }
    }
}

class ThreadB extends Thread {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void run() {
        synchronized (lock1) {
            try {
                System.out.println("Thread B acquire lock1");
                // 等待锁2可用
                synchronized (lock2) {
                    System.out.println("Thread B acquire lock2");
                    // 释放锁1，让线程A获取
                    lock1.notify();
                    // 再等待锁2释放，再次获取锁2
                    lock2.wait();
                    System.out.println("Thread B release lock2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                System.out.println("Thread B release lock1");
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

// 启动线程
        threadA.start();
        threadB.start();
    }
}
```

在这个例子中，两个线程`ThreadA`和`ThreadB`分别持有锁1和锁2。如果线程A先获取到锁1，然后等待锁2释放，但此时线程B已经获取了锁2并占用。线程A无法释放自己的锁1去获取锁2，因此形成了死锁。