Java多线程并发控制：死锁实例

原创秒速五厘米 2024-12-08 06:21 18阅读 0赞

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

以下是一个经典的死锁实例：

```java
// 定义线程类
class ThreadA extends Thread {
    private Object lockA = new Object();
    private Object lockB = new Object();

public void run() {
        synchronized (lockA) {
            // 获取锁A，同时释放锁B
            synchronized (lockB) {
                System.out.println("Thread A: Acquire lock A and B");
                // 模拟一些耗时操作
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread A: Release lock B");
            }
            System.out.println("Thread A: Release lock A");
        }
    }
}

class ThreadB extends Thread {
    private Object lockA = new Object();
    private Object lockB = new Object();

public void run() {
        synchronized (lockA) {
            // 获取锁A，同时释放锁B
            synchronized (lockB) {
                System.out.println("Thread B: Acquire lock A and B");
                // 模拟一些耗时操作
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread B: Release lock B");
            }
            System.out.println("Thread B: Release lock A");
        }
    }
}

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

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

在这个例子中，`ThreadA`需要先获取到`lockA`和`lockB`，然后释放`lockB`。同样地，`ThreadB`也需要先获取到这两个锁，然后释放`lockB`。

这样，两个线程就形成了相互等待的死锁状态。