Java并发编程中，死锁问题实例展示

原创墨蓝 2024-09-05 16:39 64阅读 0赞

在Java并发编程中，死锁是一个常见的问题。它发生在两个或更多的进程，在执行过程中因争夺资源而造成的一种相互等待的现象。

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

```java
// 进程1
class Process1 extends Thread {
    Object lock1 = new Object();
    Object lock2 = new Object();

public void run() {
        try {
            // 争夺锁1
            synchronized (lock1) {
                // 获取锁2
                synchronized (lock2) {
                    System.out.println("Process 1: Both locks acquired");
                }
            }

// 释放锁1
            lock1.notify();

// 再次尝试获取锁2，可能会等待
            try {
                synchronized (lock2) {
                    System.out.println("Process 1: Attempted to acquire second lock");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

// 进程2
class Process2 extends Thread {
    Object lock1 = new Object();
    Object lock2 = new Object();

public void run() {
        try {
            // 争夺锁2
            synchronized (lock2) {
                // 获取锁1
                synchronized (lock1) {
                    System.out.println("Process 2: Both locks acquired");
                }
            }

// 释放锁2
            lock2.notify();

// 再次尝试获取锁1，可能会等待
            try {
                synchronized (lock1) {
                    System.out.println("Process 2: Attempted to acquire first lock");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

public class DeadLockExample {
    public static void main(String[] args) {
        Process1 proc1 = new Process1();
        Process2 proc2 = new Process2();

proc1.start();
        proc2.start();
    }
}
```

在这个例子中，`Process1` 和 `Process2` 两个线程分别获取了 `lock1` 和 `lock2`。这两个锁是相互等待的，因此导致了死锁。