Java多线程的地狱级 Bug：死锁如何产生？如何避免？-CSDN博客

本文链接：https://blog.csdn.net/java_beautiful/article/details/148477779

Java多线程的地狱级 Bug：死锁如何产生？如何避免？

首先，我需要明确死锁到底是什么，为什么会发生。可能的话，我应该从基本概念开始，逐步深入。

我记得死锁通常发生在多个线程互相等待对方释放资源的时候。比如，线程A持有资源1，同时请求资源2；而线程B持有资源2，同时请求资源1。这时候两个线程都无法继续执行，形成死锁。这种情况下，程序就会卡住，无法继续运行。

那么，在Java中，具体是怎么产生死锁的呢？可能涉及到synchronized关键字或者显式的锁，比如ReentrantLock。当多个线程以不同的顺序获取锁时，就容易出现死锁。比如，两个线程各自先获取一个锁，然后再尝试获取另一个线程已经持有的锁，这样就会互相等待。

比如，假设有两个对象obj1和obj2，线程1先锁住obj1，然后尝试锁住obj2；而线程2先锁住obj2，再尝试锁住obj1。如果这两个操作同时发生，就会导致死锁。这时候，两个线程都在等待对方释放锁，但自己又不释放已持有的锁，导致无限等待。

接下来，我需要想一下如何避免死锁。避免死锁的方法应该涉及到破坏死锁产生的条件。根据操作系统中的知识，死锁的四个必要条件是：互斥、持有并等待、不可抢占、循环等待。要避免死锁，就要破坏其中一个或多个条件。

比如，破坏循环等待条件可以通过规定所有线程以相同的顺序获取锁。例如，要求所有线程必须先获取obj1的锁，再获取obj2的锁，这样就不会出现循环等待的情况了。或者，使用锁的排序，比如按照对象的哈希值或者某个固定顺序来获取锁，确保所有线程都按照同样的顺序请求资源。

另外，使用tryLock()方法也可以避免死锁。比如，在尝试获取锁的时候，设置超时时间，如果一段时间内无法获取所有需要的锁，就释放已经持有的锁，等待一段时间后再重试。这样可以避免线程一直阻塞，从而减少死锁的可能性。

还有一种方法是使用更高级别的并发工具，比如使用java.util.concurrent包中的类，如Semaphore、CountDownLatch等，这些工具可能已经内部处理了锁的问题，减少了手动管理锁的需要，从而降低死锁风险。

不过，可能在实际编码中，最常见的建议还是按照固定的顺序获取锁，这样就能避免循环等待。例如，如果有多个锁需要获取，不管线程需要哪些锁，都必须按照全局一致的顺序去申请，这样就不会出现互相等待对方锁的情况。

那如何检测死锁呢？在Java中，可以使用工具如jstack，或者使用ThreadMXBean来检测死锁。比如，通过ThreadMXBean的findDeadlockedThreads()方法，可以找到处于死锁状态的线程，从而进行相应的处理，比如记录日志或者重启服务等。

不过，避免死锁主要还是应该在代码设计阶段就考虑，而不是依赖检测。比如，在编写多线程代码时，避免嵌套锁，或者尽量减少锁的作用范围，使用同步块而不是同步方法，这样锁的持有时间更短，减少竞争的可能性。另外，使用无锁的数据结构，比如ConcurrentHashMap，也能减少死锁的发生。

另外，银行家算法是一种避免死锁的算法，不过可能在Java中应用起来比较复杂，需要预先知道资源的最大需求，这在动态的线程环境中可能不太实际。所以，可能更实用的还是锁顺序和超时机制。

总结一下，产生死锁的条件是四个必要条件，避免死锁的方法包括：固定锁的获取顺序、使用超时锁、减少锁的持有时间、使用更高级的并发工具等。在实际编码中，应该注意锁的顺序，避免交叉锁，以及合理设计资源分配策略。

在Java多线程编程中，死锁是一种严重的并发问题，会导致程序卡死。以下是死锁的产生原因及避免方法：

死锁产生的条件（四个必要条件）

互斥：资源一次只能被一个线程占用。
持有并等待：线程持有资源并等待其他线程释放资源。
不可抢占：资源只能由持有它的线程主动释放。
循环等待：多个线程形成环形等待链，每个线程都在等待下一个线程持有的资源。

示例场景：

Object lockA = new Object();
Object lockB = new Object();

// 线程1：先获取lockA，再请求lockB
new Thread(() -> {
    synchronized (lockA) {
        synchronized (lockB) { /* ... */ }
    }
}).start();

// 线程2：先获取lockB，再请求lockA
new Thread(() -> {
    synchronized (lockB) {
        synchronized (lockA) { /* ... */ }
    }
}).start();

当两个线程同时运行时，可能互相等待对方释放锁，导致死锁。

如何避免死锁

1. 破坏循环等待条件：固定锁的获取顺序

全局定义锁的顺序：所有线程必须按相同顺序获取锁（如按对象的哈希值排序）。
复制
// 确保所有线程先获取lockA，再获取lockB
public void doWork()
{
synchronized (lockA)
{
synchronized (lockB)
{ /* ... */
}
}
}

2. 使用超时机制（破坏持有并等待）

通过tryLock()尝试获取锁，若超时则释放已持有的锁并重试。
Lock lockA = new ReentrantLock();
Lock lockB = new ReentrantLock();
if (lockA.tryLock(1, TimeUnit.SECONDS))
{ try {
if (lockB.tryLock(1, TimeUnit.SECONDS))
{
try { /* ... */ } finally { lockB.unlock();
}
}
}
finally { lockA.unlock(); } }

3. 减少锁的作用范围

缩小同步代码块，避免嵌套锁。
// 不推荐：同步整个方法 public synchronized void method() { /* ... */ } // 推荐：仅同步必要部分 public void method() { synchronized (this) { /* 关键代码 */ } }

4. 使用高级并发工具

优先使用java.util.concurrent包中的工具（如ConcurrentHashMap、Semaphore等），减少手动管理锁的需求。

5. 死锁检测与恢复

检测工具：使用jstack或ThreadMXBean检测死锁。
ThreadMXBean bean = ManagementFactory.getThreadMXBean(); long[] threadIds = bean.findDeadlockedThreads(); if (threadIds != null) { // 处理死锁（如记录日志、中断线程） }
恢复策略：强制终止线程或回滚操作（需谨慎设计）。