多线程概念部分死锁-java教程-PHP中文网

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

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

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

Multithreading Concepts Part Deadlock

探索并发的复杂轨迹

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

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

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

1.什么是死锁？

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

2. 死锁发生的条件

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

互斥：至少一个资源必须以不可共享模式保存，这意味着一次只有一个线程可以使用它。
持有并等待：线程必须持有一种资源，并等待获取其他线程持有的其他资源。
无抢占：无法从线程中强行夺走资源。他们必须自愿释放。
循环等待：存在一个封闭的线程链，其中每个线程至少拥有链中下一个线程所需的一个资源。

Multithreading Concepts Part Deadlock

我们用时序图来理解

Multithreading Concepts Part Deadlock

在上面的动画中，

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

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

3. 检测/监控死锁

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

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

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

4. 预防死锁的策略

应用等待死亡和伤口等待方案
等待死亡方案：当一个线程请求另一个线程持有的锁时，数据库会评估相对优先级（通常基于每个线程的时间戳）。如果请求线程的优先级较高，则等待；否则，它会死掉（重新启动）。
Wound-Wait 方案：如果请求线程具有较高优先级，它会通过强制释放锁来破坏（抢占）较低优先级线程。
共享状态的不可变对象
尽可能将共享状态设计为不可变。由于不可变对象无法修改，因此它们无需锁即可进行并发访问，从而降低死锁风险并简化代码。
使用带有超时的 tryLock 来获取锁：与标准同步块不同，ReentrantLock 允许使用 tryLock(timeout, unit) 在指定时间内尝试获取锁。如果在此时间内未获取锁，它将释放资源，防止无限期阻塞。

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。这种做法在较大的应用程序中可能具有挑战性，但对于降低死锁风险非常有效。

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

public class LockOrderingExample {

    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            acquireLocksInOrder(lock1, lock2);
        });

        Thread thread2 = new Thread(() -> {
            acquireLocksInOrder(lock1, lock2);
        });

        thread1.start();
        thread2.start();
    }

    private static void acquireLocksInOrder(Lock firstLock, Lock secondLock) {
        try {
            firstLock.lock();
            System.out.println(Thread.currentThread().getName() + " acquired lock1");

            secondLock.lock();
            System.out.println(Thread.currentThread().getName() + " acquired lock2");

            // Perform some operations

        } finally {
            secondLock.unlock();
            System.out.println(Thread.currentThread().getName() + " released lock2");

            firstLock.unlock();
            System.out.println(Thread.currentThread().getName() + " released lock1");
        }
    }
}

登录后复制

使用线程安全/并发集合：Java 的 java.util.concurrent 包提供了常见数据结构（ConcurrentHashMap、CopyOnWriteArrayList 等）的线程安全实现，可以在内部处理同步，减少需要显式锁。这些集合最大限度地减少了死锁，因为它们旨在使用内部分区等技术来避免显式锁定的需要。
避免嵌套锁
尽量减少在同一块内获取多个锁以避免循环依赖。如果需要嵌套锁，请使用一致的锁顺序

软件工程师的要点

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

尾奏

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

当我们继续了解多线程的核心概念时，请继续关注本系列的下一篇文章。我们将深入关键部分，了解如何在多个线程之间安全地管理共享资源。我们还将讨论竞争条件的概念，这是一种常见的并发问题，如果不加以控制，可能会导致不可预测的行为和错误。

通过每一步，您都会更深入地了解如何使您的应用程序线程安全、高效且具有弹性。不断突破多线程知识的界限，构建更好、性能更高的软件！