Java多线程处理：常见的死锁问题案例

原创朱雀 2024-12-08 05:00 4阅读 0赞

在Java多线程编程中，死锁是一种严重的错误状态。当两个或更多线程因争夺资源而造成的一种相互等待的现象，就称为死锁。

下面是一个典型的死锁案例：

```java
public class DeadLockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void thread1() {
        synchronized (lock1) { //占有资源1的锁
            System.out.println("Thread 1: Acquiring lock 2...");
            try {
                synchronized (lock2) { //占有资源2的锁
                    System.out.println("Thread 1: Both locks acquired!");
                    // 此处可能会导致死锁，因为线程1没有释放锁2
                    Thread.sleep(500); //模拟长时间操作
                }
            } catch (InterruptedException e) {
                System.out.println("Thread 1: Interrupted while acquiring lock 2.");
                e.printStackTrace();
            } finally {
                System.out.println("Thread 1: Releasing lock 1...");
                lock1.notifyAll(); //唤醒所有等待锁1的线程
            }
        }
    }

public void thread2() {
        synchronized (lock2) { //占有资源2的锁
            System.out.println("Thread 2: Acquiring lock 1...");
            try {
                synchronized (lock1) { //占有资源1的锁
                    System.out.println("Thread 2: Both locks acquired!");
                    // 此处可能会导致死锁，因为线程2没有释放锁1
                    Thread.sleep(500); //模拟长时间操作
                }
            } catch (InterruptedException e) {
                System.out.println("Thread 2: Interrupted while acquiring lock 1.");
                e.printStackTrace();
            } finally {
                System.out.println("Thread 2: Releasing lock 2...");
                lock2.notifyAll(); //唤醒所有等待锁2的线程
            }
        }
    }

public static void main(String[] args) {
        DeadLockExample example = new DeadLockExample();
        Thread thread1 = new Thread(example::thread1));
        Thread thread2 = new Thread(example::thread2));

thread1.start();
        thread2.start();
    }
}
```

在这个例子中，线程1需要先占有资源1的锁（lock1），然后才能去占有资源2的锁（lock2）。同样，线程2也需要遵循这个顺序。

如果两个线程的执行顺序是这样的：线程1先占有资源1的锁，然后去占有资源2的锁；接着，线程2也占有资源2的锁，然后去占有资源1的锁。那么就会发生死锁，因为两个线程都无法释放已经占有的资源锁，从而导致相互等待，无法继续执行任务。