欢迎来到我们的多线程系列的第 3 部分！

• 在第 1 部分中，我们探讨了原子性 和 不变性。
• 在第 2 部分中，我们讨论了饥饿。

在这一部分中，我们将深入研究多线程中死锁的机制。原因是什么，如何识别以及可以使用的预防策略，以避免将代码变成僵局。应用程序逐渐停止，通常没有任何明显的错误，让开发人员感到困惑，系统冻结。

探索并发的复杂轨迹

理解死锁的一个有用的类比是想象一个铁路网络，在相交的轨道上有多列火车。

由于每列火车都在等待下一列火车开动，因此没有一列火车可以继续行驶，从而导致僵局。在这种情况下，低效的信号系统允许每列列车进入各自的路段，而无需先确认下一段是否空闲，从而将所有列车陷入牢不可破的循环中。

这个火车示例说明了多线程中的典型死锁，其中线程（如火车）在等待其他资源被释放时保留资源（轨道部分），但没有一个可以前进。为了防止这种软件死锁，必须实施有效的资源管理策略（类似于更智能的铁路信号），以避免循环依赖并确保每个线程的安全通道。

1.什么是死锁？

死锁是一种线程（或进程）无限期阻塞、等待其他线程持有的资源的情况。这种情况会导致无法打破的依赖关系循环，任何涉及的线程都无法取得进展。在探索检测、预防和解决方法之前，了解死锁的基础知识至关重要。

2. 死锁发生的条件

要发生死锁，必须同时满足四个条件，称为科夫曼条件：

• 互斥： 至少一个资源必须以不可共享模式保存，这意味着一次只有一个线程可以使用它。

• 持有并等待：线程必须持有一种资源，并等待获取其他线程持有的其他资源。

• 无抢占： 不能从线程中强行夺走资源。他们必须自愿释放。

• 循环等待： 存在一个封闭的线程链，其中每个线程至少拥有链中下一个线程所需的一个资源。

我们理解为时序图

在上面的动画中，

• 线程A持有资源1并等待资源2
• 当线程B持有资源2并等待资源1时

上面共享的死锁的所有四个条件都存在，这会导致无限期的阻塞。打破其中任何一个都可以防止死锁。

3. 检测/监控死锁

检测死锁，尤其是在大规模应用程序中，可能具有挑战性。但是，以下方法可以帮助识别死锁

• 工具：Java的JConsole、VisualVM以及IDE中的线程分析器可以实时检测死锁。
• 线程转储和日志：分析线程转储可以揭示等待线程及其所持有的资源。

有关如何调试/监视死锁的详细概述，请访问使用 VisualVM 和 jstack 调试和监视死锁

4. 预防死锁的策略

• 应用等待死亡和伤口等待方案
  等待死亡方案：当一个线程请求另一个线程持有的锁时，数据库会评估相对优先级（通常基于每个线程的时间戳）。如果请求线程的优先级较高，则等待；否则，它会死掉（重新启动）。
  Wound-Wait 方案：如果请求线程具有较高优先级，它会通过强制释放锁来伤害（抢占）较低优先级线程。

• 共享状态的不可变对象 尽可能将共享状态设计为不可变。由于不可变对象无法修改，因此它们不需要锁
  进行并发访问，降低死锁风险并简化代码。

• 使用带有超时的tryLock来获取锁

  ：与标准同步块不同，ReentrantLock允许使用tryLock(timeout,unit)在指定的时间内尝试获取锁。如果在此时间内未获取锁，它将释放资源，防止无限期阻塞。
  

ReentrantLock 锁1 = new ReentrantLock(); ReentrantLock lock2 = new ReentrantLock(); 公共无效acquireLocks（）{ 尝试 { if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) { 尝试 { if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) { // 临界区 } } 最后 { lock2.unlock(); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } 最后 { lock1.unlock(); } }

ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

public void acquireLocks() {
    try {
        if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                    // Critical section
                }
            } finally {
                lock2.unlock();
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        lock1.unlock();
    }
}

锁定排序和释放
• 为锁获取设置严格的全局顺序。如果所有线程以一致的顺序获取锁，则不太可能形成循环依赖，从而避免死锁。例如，在整个代码库中始终先获取 lock1，然后再获取 lock2。这种做法在较大的应用程序中可能具有挑战性，但对于降低死锁风险非常有效。
导入java.util.concurrent.locks.Lock; 导入 java.util.concurrent.locks.ReentrantLock; 公共类LockOrderingExample { 私有静态最终锁lock1 = new ReentrantLock(); 私有静态最终锁lock2 = new ReentrantLock(); 公共静态无效主（字符串[] args）{ 线程 thread1 = new Thread(() -> { acquireLocksInOrder(锁1,锁2); }); 线程 thread2 = new Thread(() -> { acquireLocksInOrder(锁1,锁2); }); 线程1.start(); 线程2.start(); } 私有静态无效 acquireLocksInOrder（锁定第一锁，锁定第二锁）{ 尝试 { 首先Lock.lock(); System.out.println(Thread.currentThread().getName() "获取了lock1"); SecondLock.lock(); System.out.println(Thread.currentThread().getName() "获得锁2"); // 执行一些操作 } 最后 { SecondLock.unlock(); System.out.println(Thread.currentThread().getName() "释放锁2"); 首先Lock.unlock(); System.out.println(Thread.currentThread().getName() "释放了lock1"); } } }

ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

public void acquireLocks() {
    try {
        if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                    // Critical section
                }
            } finally {
                lock2.unlock();
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        lock1.unlock();
    }
}

• 使用线程安全/并发集合

  ：Java的java.util.concurrent包提供了常见数据结构（ConcurrentHashMap、CopyOnWriteArrayList等）的线程安全实现，可以在内部处理同步，减少需要显式锁。这些集合最大限度地减少了死锁，因为它们旨在使用内部分区等技术来避免显式锁定的需要。

• 避免嵌套锁

  尽量减少在同一块内获取多个锁以避免循环依赖。如果需要嵌套锁，请使用一致的锁顺序
  

软件工程师的要点

死锁
• 是由进程之间的依赖关系循环引起的阻塞问题。没有进程可以取得进展，因为每个进程都在等待另一个进程持有的资源，并且没有一个进程可以继续释放资源。
死锁
• 更为严重，因为它会完全停止所涉及的进程，并且需要打破死锁循环才能恢复。
死锁
• 仅当有两个不同的锁时才会发生，即当您持有一个锁并等待另一个锁释放时。 （但是，死锁还有更多条件）。
线程安全
• 并不意味着无死锁。它仅保证代码将根据其接口进行操作，即使是从多个线程调用时也是如此。使类线程安全通常包括添加锁以保证安全执行。
尾奏

无论您是初学者还是经验丰富的开发人员，了解死锁对于在并发系统中编写健壮、高效的代码至关重要。在本文中，我们探讨了死锁是什么、其原因以及预防死锁的实用方法。通过实施有效的资源分配策略、分析任务依赖性以及利用线程转储和死锁检测工具等工具，开发人员可以最大限度地降低死锁风险并优化其代码以实现平滑并发。

关键部分

，了解如何在多个线程之间安全地管理共享资源。我们还将讨论竞争条件的概念，这是一种常见的并发问题，如果不加以控制，可能会导致不可预测的行为和错误。 通过每一步，您将更深入地了解如何使您的应用程序线程安全、高效且具有弹性。不断突破多线程知识的界限，构建更好、性能更高的软件！

参考

• 信息图表
• 如何检测和修复死锁