Java多线程：死锁现象及防范措施

原创左手的ㄟ右手 2024-11-07 09:39 28阅读 0赞

Java多线程中的死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行下去。死锁发生时，线程会陷入无限等待状态，无法继续执行，从而影响程序的正常运行。

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

###死锁的防范措施1. **避免占有和等待条件**：确保线程在开始执行前就获取所有需要的资源，或者在等待资源时释放已占有的资源。

2. **资源有序分配**：按照一定的顺序分配资源，确保所有线程都按照这个顺序请求资源。

3. **使用超时机制**：在请求资源时设置超时时间，如果超时则释放已占有的资源并重新尝试。

4. **检测死锁并恢复**：通过系统监控检测死锁，并采取相应措施，如终止线程、回滚事务等。

5. **使用死锁避免算法**：如银行家算法，动态检测资源分配情况，避免死锁发生。

6. **减少锁的粒度**：使用更细粒度的锁，减少线程间的竞争。

7. **使用并发库**：Java提供了一些并发库，如`java.util.concurrent`，这些库中的类和方法设计时已经考虑了死锁问题。

8. **避免嵌套锁**：尽量减少锁的嵌套使用，如果必须使用，确保所有线程以相同的顺序获取锁。

9. **使用`ReentrantLock`代替`synchronized`**：`ReentrantLock`提供了更灵活的锁定机制，如尝试非阻塞获取锁、可中断的锁获取等。

10. **使用`java.util.concurrent.locks.Lock`和`Condition`**：这些提供了比`synchronized`更高级的锁和条件变量，有助于避免死锁。

### 示例代码```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

public static void main(String[] args) {
 new Thread(() -> {
lock1.lock();
 try {
 System.out.println("Thread1: Locked lock1");
//模拟处理时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
lock2.lock();
 try {
 System.out.println("Thread1: Locked lock2");
} finally {
lock2.unlock();
 }
} finally {
lock1.unlock();
 }
 }).start();

new Thread(() -> {
lock2.lock();
 try {
 System.out.println("Thread2: Locked lock2");
//模拟处理时间 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
lock1.lock();
 try {
 System.out.println("Thread2: Locked lock1");
} finally {
lock1.unlock();
 }
} finally {
lock2.unlock();
 }
 }).start();
 }
}
```在这个示例中，两个线程尝试以不同的顺序锁定两个锁，这可能导致死锁。为了避免这种情况，可以确保所有线程都以相同的顺序请求锁，或者使用超时机制等策略。