Java并发编程中，死锁的产生及解决方案：实例解读

原创梦里梦外; 2024-10-31 07:48 21阅读 0赞

Java并发编程中，死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，使得这些线程无法继续执行下去。死锁的产生通常需要满足以下四个条件：

1. **互斥条件**：资源不能被多个线程共享，只能由一个线程独占。
2. **占有和等待条件**：一个线程至少占有一个资源，并且等待获取其他线程占有的资源。
3. **不可抢占条件**：资源只能由占有它的线程自愿释放。
4. **循环等待条件**：存在一个线程的集合，其中每个线程都在等待下一个线程所占有的资源。

###死锁的产生实例假设有两个资源A和B，以及两个线程T1和T2：

```javapublic class DeadLockExample {
 private static Object resource1 = new Object();
 private static Object resource2 = new Object();

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

new Thread(() -> {
 synchronized (resource2) {
 System.out.println("Thread2: Locked resource2");
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (resource1) {
 System.out.println("Thread2: Locked resource1");
 }
 }
}, "Thread2").start();
 }
}
```在这个例子中，`Thread1`首先锁定了`resource1`，然后尝试锁定`resource2`。同时，`Thread2`首先锁定了`resource2`，然后尝试锁定`resource1`。由于两个线程都在等待对方释放资源，因此发生了死锁。

###死锁的解决方案1. **避免使用嵌套同步**：重新设计程序结构，避免一个线程需要等待多个资源的情况。
2. **使用定时锁**：使用`tryLock()`方法尝试获取锁，如果失败则等待一段时间后重试。
3. **有序锁定**：确保所有线程以相同的顺序请求资源。
4. **死锁检测**：周期性地检查系统是否发生死锁，并尝试恢复。
5. **使用并发库**：使用Java并发库中的高级同步工具，如`ReentrantLock`、`Semaphore`等，它们提供了更灵活的锁定机制。

### 实例解读解决方案使用`ReentrantLock`和`tryLock()`方法避免死锁：

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

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

public static void main(String[] args) {
 new Thread(() -> {
if (lock1.tryLock()) {
 try {
 System.out.println("Thread1: Locked lock1");
if (lock2.tryLock()) {
 try {
 System.out.println("Thread1: Locked lock2");
} finally {
 lock2.unlock();
 }
 }
} finally {
lock1.unlock();
 }
 }
}, "Thread1").start();

new Thread(() -> {
if (lock2.tryLock()) {
 try {
 System.out.println("Thread2: Locked lock2");
if (lock1.tryLock()) {
 try {
 System.out.println("Thread2: Locked lock1");
} finally {
 lock1.unlock();
 }
 }
} finally {
lock2.unlock();
 }
 }
}, "Thread2").start();
 }
}
```在这个例子中，我们使用了`tryLock()`方法来尝试获取锁，如果获取失败，则不会阻塞线程，从而避免了死锁的发生。