Java多线程中的死锁示例及解决方案

原创本是古典何须时尚 2024-11-12 05:54 17阅读 0赞

死锁是多线程编程中常见的问题之一，它发生在两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行下去。下面是一个简单的Java死锁示例以及解决方案。

###死锁示例```javapublic class DeadlockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 synchronized (lock1) {
 System.out.println("Thread1: Locked lock1");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Thread1: Locked lock2");
 }
 }
 });

Thread t2 = new Thread(() -> {
 synchronized (lock2) {
 System.out.println("Thread2: Locked lock2");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2: Locked lock1");
 }
 }
 });

t1.start();
t2.start();
 }
}
```在这个示例中，`t1` 和 `t2`两个线程分别尝试获取两个锁 `lock1` 和 `lock2`。`t1`先获取 `lock1`，然后尝试获取 `lock2`；而 `t2`先获取 `lock2`，然后尝试获取 `lock1`。由于两个线程都需要对方已经持有的锁，因此它们会互相等待，导致死锁。

###解决方案1. **避免同时锁定多个资源**：确保每个线程一次只锁定一个资源，或者使用单个锁来锁定所有资源。

2. **使用锁顺序**：所有线程按照相同的顺序获取锁。

3. **使用超时机制**：使用 `tryLock` 方法尝试获取锁，并设置超时时间。

4. **使用死锁检测工具**：Java提供了一些工具，如JConsole和VisualVM，可以帮助检测死锁。

5. **使用`ReentrantLock`代替`synchronized`**：`ReentrantLock` 提供了更多的灵活性，比如尝试非阻塞地获取锁、可中断的锁获取等。

下面是使用`ReentrantLock`和超时机制来避免死锁的示例：

```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockSolution {
 private static final Lock lock1 = new ReentrantLock();
 private static final Lock lock2 = new ReentrantLock();

public static void main(String[] args) {
Thread t1 = new Thread(() -> {
lock1.lock();
 try {
 System.out.println("Thread1: Locked lock1");
if (lock2.tryLock(100, java.util.concurrent.TimeUnit.MILLISECONDS)) {
 try {
 System.out.println("Thread1: Locked lock2");
} finally {
lock2.unlock();
 }
 }
} finally {
lock1.unlock();
 }
 });

Thread t2 = new Thread(() -> {
lock2.lock();
 try {
 System.out.println("Thread2: Locked lock2");
if (lock1.tryLock(100, java.util.concurrent.TimeUnit.MILLISECONDS)) {
 try {
 System.out.println("Thread2: Locked lock1");
} finally {
lock1.unlock();
 }
 }
} finally {
lock2.unlock();
 }
 });

t1.start();
t2.start();
 }
}
```在这个解决方案中，我们使用了`ReentrantLock`和`tryLock`方法，并且设置了100毫秒的超时时间。如果一个线程在指定的时间内无法获取所有需要的锁，它将放弃并释放已持有的锁，从而避免死锁。