Java并发编程：死锁现象实例解析

原创不念不忘少年蓝@ 2024-11-28 21:12 61阅读 0赞

死锁是并发编程中的一个重要问题，它发生在两个或更多的进程在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行。

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

```java
// 线程1
public class Thread1 extends Thread {
    private Object lockA = new Object();
    private Object lockB = new Object();

public void run() {
        synchronized (lockA) {
            try {
                // 为线程2预留资源
                synchronized (lockB) {
                    System.out.println("Thread1 acquired both locks.");
                    // 死锁条件，等待对方释放锁
                    lockB.wait();
                }
                System.out.println("Thread1 released lock A.");
            } catch (InterruptedException e) {
                System.out.println("Thread1 interrupted: " + e.getMessage());
                Thread.currentThread().interrupt(); // 重置中断标志
            }
        }
    }
}

// 线程2
public class Thread2 extends Thread {
    private Object lockA = new Object();
    private Object lockB = new Object();

public void run() {
        synchronized (lockA) {
            try {
                // 先获取锁B，为线程1预留资源
                synchronized (lockB) {
                    System.out.println("Thread2 acquired both locks.");
                    // 线程1释放锁A后，等待锁B的释放来继续执行
                    lockA.notify();
                }
                System.out.println("Thread2 released lock B.");
            } catch (InterruptedException e) {
                System.out.println("Thread2 interrupted: " + e.getMessage());
                Thread.currentThread().interrupt(); // 重置中断标志
            }
        }
    }
}

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

// 启动两个线程
        thread1.start();
        thread2.start();
    }
}
```

当程序执行到`Thread2`获取锁`B`后释放锁`A`时，`Thread1`会等待锁`A`的释放。但是由于`Thread1`先获取了锁`B`，所以它会一直等待，形成死锁。

要避免这种情况，通常我们会遵循"资源互斥原则"，即两个线程不能同时访问和操作相同的资源。