JAVA并发可重入锁与不可重入锁错误使用导致死锁的典型案例 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JAVA并发：可重入锁与不可重入锁的死锁陷阱

大家好，今天我们来聊聊Java并发编程中一个非常重要但又容易被忽视的问题：可重入锁与不可重入锁在错误使用时导致的死锁。死锁是多线程编程中一个非常棘手的问题，它会导致程序卡死，资源无法释放，严重影响系统的可用性。理解死锁的原因，掌握避免死锁的技巧，是每个Java开发者必备的技能。

一、什么是可重入锁和不可重入锁？

在深入探讨死锁案例之前，我们首先要理解可重入锁和不可重入锁的概念。

不可重入锁（Non-Reentrant Lock）： 不可重入锁是指当一个线程已经获取了该锁之后，如果再次尝试获取该锁，那么该线程将会被阻塞。也就是说，同一个线程不能重复获取同一个锁。
可重入锁（Reentrant Lock）： 可重入锁允许一个线程多次获取同一个锁。它的实现通常会维护一个计数器，记录线程获取锁的次数。当线程第一次获取锁时，计数器加1；当线程释放锁时，计数器减1。只有当计数器变为0时，锁才真正被释放，其他线程才能获取该锁。

Java中synchronized关键字以及java.util.concurrent.locks.ReentrantLock都是可重入锁。我们通常使用的锁都是可重入锁，这是因为可重入性可以避免很多潜在的死锁问题。

二、不可重入锁的简单实现

为了更好地理解不可重入锁，我们先来简单实现一个不可重入锁：

public class NonReentrantLock {

    private boolean isLocked = false;

    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait();
        }
        isLocked = true;
    }

    public synchronized void unlock() {
        if (isLocked) {
            isLocked = false;
            notify();
        }
    }
}

这个NonReentrantLock非常简单，使用一个isLocked标志位来表示锁是否被占用。lock()方法会一直等待直到锁可用，然后将其设置为占用状态。unlock()方法会释放锁，并通知等待线程。

三、不可重入锁导致死锁的经典案例

现在，我们来看一个使用上面实现的NonReentrantLock导致死锁的经典案例：

public class NonReentrantLockExample {

    private NonReentrantLock lock = new NonReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Outer method acquired lock");
            inner();
        } finally {
            lock.unlock();
            System.out.println("Outer method released lock");
        }
    }

    public void inner() throws InterruptedException {
        lock.lock(); // Potential deadlock here
        try {
            System.out.println("Inner method acquired lock");
        } finally {
            lock.unlock();
            System.out.println("Inner method released lock");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        NonReentrantLockExample example = new NonReentrantLockExample();
        example.outer();
    }
}

在这个例子中，outer()方法首先获取锁，然后调用inner()方法。inner()方法也尝试获取同一个锁。由于NonReentrantLock是不可重入的，当inner()方法尝试获取锁时，线程会被阻塞，因为它已经被outer()方法持有了。而outer()方法必须等待inner()方法执行完毕并释放锁才能继续执行，这就造成了死锁。

程序的执行流程如下：

main方法创建NonReentrantLockExample实例。
main方法调用example.outer()。
outer()方法调用lock.lock()，成功获取锁。
outer()方法打印 "Outer method acquired lock"。
outer()方法调用inner()方法。
inner()方法调用lock.lock()，由于锁已经被outer()方法持有，线程被阻塞。
outer()方法等待inner()方法释放锁，但inner()方法又在等待outer()方法释放锁，形成死锁。

程序会一直卡在inner()方法的lock.lock()调用处，无法继续执行。

四、可重入锁如何避免死锁

如果我们将上面的例子中的NonReentrantLock替换为ReentrantLock，就不会发生死锁。

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {

    private ReentrantLock lock = new ReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Outer method acquired lock");
            inner();
        } finally {
            lock.unlock();
            System.out.println("Outer method released lock");
        }
    }

    public void inner() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Inner method acquired lock");
        } finally {
            lock.unlock();
            System.out.println("Inner method released lock");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockExample example = new ReentrantLockExample();
        example.outer();
    }
}

在这个例子中，ReentrantLock是可重入的。当outer()方法调用inner()方法时，inner()方法也可以成功获取锁，因为它们是同一个线程。ReentrantLock会维护一个计数器，记录线程获取锁的次数。当outer()方法第一次获取锁时，计数器加1；当inner()方法获取锁时，计数器再加1。当inner()方法释放锁时，计数器减1；当outer()方法释放锁时，计数器再减1。只有当计数器变为0时，锁才真正被释放。

程序的执行流程如下：

main方法创建ReentrantLockExample实例。
main方法调用example.outer()。
outer()方法调用lock.lock()，成功获取锁（计数器变为1）。
outer()方法打印 "Outer method acquired lock"。
outer()方法调用inner()方法。
inner()方法调用lock.lock()，由于锁已经被同一个线程持有，可以重入，计数器变为2。
inner()方法打印 "Inner method acquired lock"。
inner()方法调用lock.unlock()，计数器变为1。
inner()方法打印 "Inner method released lock"。
outer()方法继续执行，调用lock.unlock()，计数器变为0，锁被真正释放。
outer()方法打印 "Outer method released lock"。

程序可以正常执行，不会发生死锁。

五、死锁产生的四个必要条件

要发生死锁，必须同时满足以下四个必要条件：

条件	描述
互斥（Mutual Exclusion）	至少有一个资源是以独占模式被持有的。也就是说，一次只有一个线程能够使用该资源。如果另一个线程想要使用该资源，它必须等待直到持有该资源的线程释放之。
持有并等待（Hold and Wait）	一个线程持有了至少一个资源，并且正在等待获取其他线程持有的资源。
不可剥夺（No Preemption）	一个线程已经获取的资源，在未使用完之前，不能被强制剥夺。只能由持有它的线程主动释放。
循环等待（Circular Wait）	存在一个线程集合 {T1, T2, T3, …, Tn}，其中 T1 正在等待 T2 释放资源，T2 正在等待 T3 释放资源，依此类推，Tn 正在等待 T1 释放资源，形成一个环路。

六、打破死锁的策略

既然我们知道了死锁产生的必要条件，那么要避免死锁，就需要打破其中一个或多个条件。以下是一些常见的打破死锁的策略：

打破互斥条件： 这种方法不太可行，因为很多资源天生就是互斥的，比如数据库连接、文件锁等。
打破持有并等待条件： 可以要求线程在申请资源之前，一次性申请所有需要的资源。如果无法一次性获取所有资源，就释放已经获取的资源，稍后再重新尝试。
打破不可剥夺条件： 当一个线程持有一些资源，并且请求其他资源被拒绝时，它可以主动释放已经持有的资源。
打破循环等待条件： 可以通过资源排序，要求线程按照固定的顺序申请资源。这样可以避免循环等待的发生。

七、资源排序策略：避免循环等待

资源排序是一种非常有效的避免死锁的策略。它的基本思想是为所有资源定义一个全局唯一的顺序，然后要求所有线程按照这个顺序申请资源。

例如，假设我们有两个资源 A 和 B，我们定义 A 的顺序在 B 之前。那么所有线程都应该先申请 A，再申请 B。如果一个线程已经持有了 B，它就不能再申请 A。

这种策略可以有效地避免循环等待的发生，因为不可能存在一个线程集合 {T1, T2, T3, …, Tn}，其中 T1 正在等待 T2 释放资源，T2 正在等待 T3 释放资源，依此类推，Tn 正在等待 T1 释放资源，形成一个环路。因为所有的线程都按照固定的顺序申请资源，所以不可能出现循环等待的情况。

八、超时机制：应对潜在死锁

即使采取了预防死锁的措施，仍然有可能因为各种原因导致死锁。为了应对这种情况，我们可以使用超时机制。

超时机制是指在申请资源时，设置一个超时时间。如果在超时时间内无法获取资源，就放弃申请，并释放已经持有的资源。

例如，我们可以使用ReentrantLock的tryLock(long timeout, TimeUnit unit)方法来设置超时时间。如果在指定的超时时间内无法获取锁，tryLock()方法会返回false，线程可以根据返回值来决定是否放弃申请。

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

public class TimeoutExample {

    private ReentrantLock lock = new ReentrantLock();

    public void doSomething() throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                System.out.println("Acquired lock, doing something...");
                Thread.sleep(2000); // Simulate some work
            } finally {
                lock.unlock();
                System.out.println("Released lock");
            }
        } else {
            System.out.println("Failed to acquire lock within timeout");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TimeoutExample example = new TimeoutExample();
        example.doSomething();
    }
}

在这个例子中，tryLock(1, TimeUnit.SECONDS)方法会尝试在1秒内获取锁。如果成功获取锁，就执行一些操作，然后释放锁。如果超时时间内无法获取锁，就会打印 "Failed to acquire lock within timeout"。

九、死锁检测：事后补救

死锁检测是一种事后补救的策略。它是在系统运行过程中，定期检测是否存在死锁。如果检测到死锁，就采取一些措施来解除死锁。

常见的死锁检测方法包括：

资源分配图： 资源分配图是一种图形化的表示方法，用于描述系统中资源和线程之间的关系。通过分析资源分配图，可以检测是否存在循环等待。
死锁检测算法： 死锁检测算法是一种基于算法的检测方法，用于检测是否存在死锁。常见的死锁检测算法包括银行家算法等。

解除死锁的常见方法包括：

终止线程： 终止一个或多个参与死锁的线程。
资源剥夺： 强制剥夺一个或多个线程持有的资源。

死锁检测和解除死锁的实现比较复杂，通常需要在操作系统或数据库系统中实现。

十、实际案例分析：数据库连接池的死锁

数据库连接池是并发编程中经常使用的一种技术。如果使用不当，也容易导致死锁。

假设我们有一个数据库连接池，其中有两个连接。现在有两个线程 A 和 B，它们都需要执行两个 SQL 语句。线程 A 首先获取了一个连接，执行了第一个 SQL 语句，然后需要执行第二个 SQL 语句，但需要另一个连接才能执行。此时，线程 A 等待连接池中的另一个连接。

线程 B 也获取了一个连接，执行了第一个 SQL 语句，然后需要执行第二个 SQL 语句，但需要另一个连接才能执行。此时，线程 B 等待连接池中的另一个连接。

由于连接池中只有两个连接，线程 A 和 B 各自持有一个连接，并且都在等待对方释放连接，这就造成了死锁。

解决这个问题的方法有很多，比如：

增加连接池的大小： 增加连接池的大小可以减少线程等待连接的概率。
使用可重入锁： 如果数据库连接对象使用了可重入锁，那么线程就可以在同一个连接上执行多个 SQL 语句，从而避免死锁。
设置连接超时时间： 设置连接超时时间可以避免线程长时间等待连接。

总结：选择合适的锁，谨慎管理资源

通过上面的讨论，我们了解了可重入锁和不可重入锁的区别，以及不可重入锁在错误使用时可能导致的死锁问题。我们还学习了死锁产生的四个必要条件，以及打破死锁的一些策略。

避免死锁的关键在于：

理解锁的特性： 区分可重入锁和不可重入锁，根据实际需求选择合适的锁。
合理管理资源： 避免线程长时间持有资源，尽量一次性申请所有需要的资源，并按照固定的顺序申请资源。
使用超时机制： 设置合理的超时时间，避免线程长时间等待资源。
进行死锁检测： 定期检测是否存在死锁，并采取相应的措施解除死锁。

希望今天的分享能够帮助大家更好地理解Java并发编程中的死锁问题，并在实际开发中避免死锁的发生，构建更加健壮和可靠的并发系统。

JAVA并发：可重入锁与不可重入锁的死锁陷阱

发表回复 取消回复

发表回复取消回复