Java并发编程中死锁及避免策略实例

原创水深无声 2024-12-09 16:21 13阅读 0赞

在Java并发编程中，死锁是一个常见的问题。当两个或更多的线程因争夺资源而造成的一种互相等待的现象时，就会发生死锁。

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

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

public void run() {
        try {
            // 获取锁1
            synchronized (lock1) {
                // 获取锁2
                synchronized (lock2) {
                    System.out.println("Thread 1 is running the task.");
                }
            }

// 锁1释放后，尝试获取锁2
            synchronized (lock2) {
                System.out.println("Thread 1 successfully completed the task.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

public void run() {
        try {
            // 获取锁2，然后尝试获取锁1
            synchronized (lock2) {
                System.out.println("Thread 2 is running the task.");
                // 获取锁1，此时线程2无法继续
                synchronized (lock1) {
                    System.out.println("Thread 2 is blocked by Thread 1.");
                }
            }

// 线程1释放锁1后，尝试获取锁2再次阻塞
            synchronized (lock2) {
                System.out.println("Thread 2 attempted to continue after being blocked.");
                // 因此，线程2将一直等待线程1释放锁1。
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

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

在这个例子中，线程1和线程2都试图获取对方的锁。结果是两个线程都无法继续执行，形成了死锁。

避免死锁的方法通常包括：

1. 避免循环等待：即每个线程都应该能够先释放自己的锁，再尝试获取其他线程的锁。

2. 设置超时时间：如果线程在一段时间内无法获取到必要的锁，就应当放弃当前的任务。

3. 使用死锁预防算法：如银行家算法，它会限制一个线程请求资源的数量，从而避免因资源不足而导致的循环等待。