理解Java的并发问题：死锁示例

原创快来打我* 2024-10-12 18:06 44阅读 0赞

在Java编程中，理解和避免并发问题非常重要。其中，死锁是一个常见的并发问题。

死锁定义为：两个或多个进程，在执行过程中因争夺资源而造成的一种相互等待的现象，若无外力干涉它们将无法继续执行下去。

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

```java
// 线程1
class Thread1 extends Thread {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void run() {
        try {
            // 先获取lock1
            synchronized (lock1) {
                // 再获取lock2
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired both locks.");
                }
            }

// 这里可能会引发死锁
            // 模拟资源争夺，这里只需让线程循环等待即可
            for (int i = 0; i < 5; i++) {
                synchronized (lock2) {
                    try {
                        lock2.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

synchronized (lock1) {
                    try {
                        lock1.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

} catch (Exception e) {
            System.out.println("Thread 1 encountered an error: " + e);
        }
    }
}

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

public void run() {
        try {
            // 先获取lock3
            synchronized (lock3) {
                System.out.println("Thread 2 acquired lock 3.");
            }

// 这里可能会引发死锁，因为线程2还未获取到lock1和lock2
            // 模拟资源争夺，这里只需让线程循环等待即可
            for (int i = 0; i < 5; i++) {
                synchronized (lock3) {
                    try {
                        lock3.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

// 这里可能会出现死锁，因为线程2还未获取到lock1和lock2
                // 在实际编程中，应避免这样的循环等待
            }

} catch (Exception e) {
            System.out.println("Thread 2 encountered an error: " + e);
        }
    }
}

// 启动线程
Thread1 thread1 = new Thread1();
thread1.start();

Thread2 thread2 = new Thread2();
thread2.start();
```

这个示例中，两个线程分别尝试获取`lock1`和`lock3`。这样就可能导致死锁：线程A等待`lock3`，而线程B等待`lock1`且它已持有`lock3`。两线都无法继续执行，形成死锁状态。