Java并发编程中死锁的产生及避免示例

原创超、凢脫俗 2024-10-08 07:12 57阅读 0赞

死锁是多线程编程中的一个严重问题，当两个或更多的线程在执行过程中因争夺资源而造成的一种互相等待的现象称之为死锁。

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

```java
// 定义线程类
class Worker extends Thread {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void run() {
        synchronized (lock1) { // 获取锁1
            try {
                System.out.println("Thread 1: Acquiring lock2");
                // 对资源进行操作，然后获取锁2
                synchronized (lock2) {
                    System.out.println("Thread 1: Locks acquired, executing task...");
                    // 执行任务
                    Thread.sleep(500); // 模拟耗时操作
                } finally {
                    System.out.println("Thread 1: Releasing lock2");
                }
            } catch (InterruptedException e) {
                System.out.println("Thread 1: InterruptedException caught, releasing locks...");
                // 在捕获到中断后，释放锁
                try {
                    synchronized (lock1) { // 释放锁1
                        System.out.println("Thread 1: Lock1 released");
                    }
                    synchronized (lock2) { // 释放锁2
                        System.out.println("Thread 1: Lock2 released");
                    }
                } catch (Exception e) {
                    System.out.println("Thread 1: Unexpected exception caught, releasing locks...");
                }
            }
        } finally {
            System.out.println("Thread 1: Finally block executed, releasing lock1");
            // 关闭锁
            synchronized (lock1) { 
                System.out.println("Thread 1: Lock1 closed");
            }
        }
    }
}

// 主函数，创建两个线程并启动它们
public static void main(String[] args) {
    Worker worker1 = new Worker();
    Worker worker2 = new Worker();

// 将两个线程添加到当前线程的线程池中
    Thread.currentThread().getThreadPool().add(worker1);
    Thread.currentThread().getThreadPool().add(worker2);

// 启动线程
    worker1.start();
    worker2.start();
}
```

在这个示例中，我们通过使用两个锁（lock1和lock2）来模拟资源的获取。每个线程都需要先获得lock1，然后才能获得lock2进行进一步操作。

这样设计可以避免死锁的发生，因为没有线程能无限等待其他线程释放资源。