并发编程中的死锁问题：Java的案例分析

原创妖狐艹你老母 2024-11-26 09:21 38阅读 0赞

死锁是并发编程中的一种常见问题，它发生在两个或更多的线程相互等待对方释放资源时。

以下是一个使用Java编写的简单死锁案例：

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

public void thread1() {
        synchronized (lock1) {
            // 执行任务，这里为打印 "Task 1 is running"
            System.out.println("Task 1 is running");

// 等待锁2
            try {
                synchronized (lock2) {
                    // 如果锁2在此期间可用，则解开锁2并继续执行
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 解开锁1，释放资源
            lock1.notify();
        }
    }

public void thread2() {
        synchronized (lock2) {
            // 执行任务，这里为打印 "Task 2 is running"
            System.out.println("Task 2 is running");

// 等待锁1
            try {
                synchronized (lock1) {
                    // 如果锁1在此期间可用，则解开锁1并继续执行
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 解开锁2，释放资源
            lock2.notify();
        }
    }

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();

// 主线程等待两个线程全部执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("All threads have finished executing.");
    }
}
```

在这个例子中，`thread1`持有锁`lock1`，然后等待锁`lock2`。与此同时，`thread2`持有锁`lock2`，然后等待锁`lock1`。两个线程相互等待对方释放资源，这就形成了死锁。

在实际编程中，会通过设置超时时间、使用死锁检测工具等方式避免出现死锁问题。