死锁细究！

短命女 2024-03-16 12:40 8阅读 0赞

### 一、死锁的定义&危害 ###

#### 1、死锁是什么 ####

*  发生在`并发`中
 *  `互不想让`：当两个（或更多）线程（或进程）`相互持有对方所需要的资源`，又不主动释放，导致所有人都无法继续前进，导致程序陷入无尽的阻塞，这就是死锁。

![e3c92bf9cfcb4224c61680bdee7c3d62.png][]

*  多个线程造成死锁的情况
    
     *  如果多个线程之间的依赖关系是环形，存在环路的锁的依赖关系，那么也可能会发送死锁

![9f50e2478c4e08a8f31ca8414129c7be.png][]

#### 2、死锁的影响 ####

死锁的影响在不同的系统中是不一样的，这取决于系统对死锁的处理能力

*  `数据库`中： 数据库可以检测到并介入，可以通过放弃其中某个事物的锁来解决
 *  `JVM`中： JVM 无法自动处理锁，需要人工处理

#### 3、死锁的危害 ####

死锁发生的几率不高但危害大，一旦发生，多是`高并发`场景，影响用户多；甚至可能造成整个`系统奔溃`，或者子系统崩溃，或者性能降低；而且在压力测试过程`无法找出`所有潜在的死锁。

### 二、发生死锁的例子 ###

#### 1. 两个线程的简单场景 ####

代码展示：

/**
      *  必定发生死锁的情况
     */
    public class MustDeadLock implements Runnable {
        
        int flag = 1;//标记位
        static Object lock1 = new Object();
        static Object lock2 = new Object();
    
        public static void main(String[] args) {
        
            MustDeadLock r1 = new MustDeadLock();
            MustDeadLock r2 = new MustDeadLock();
            r1.flag=1;
            r2.flag=0;
            Thread thread1 = new Thread(r1);
            Thread thread2 = new Thread(r2);
    
            thread1.start();
            thread2.start();
        }
    
        @Override
        public void run() {
        
            System.out.println("flag= " + flag);
            if (flag == 1) {
        
                synchronized (lock1){
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (lock2){
        
                        System.out.println("线程1成功拿到两把锁");
                    }
                }
            }
            if (flag == 0) {
        
                synchronized (lock2){
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (lock1){
        
                        System.out.println("线程2成功拿到两把锁");
                    }
                }
    
            }
        }
    
    }

结果如下：

![a3f08d5b84414952cb5d1a7d75835bbb.png][]

thread1 启动之后拿到 lock1 并休眠 500ms ，与此同时，thread2 启动之后拿到了 lock2 并休眠 500ms ；thread1 醒来之后想去获取 lock2 ，但是 lock2 被 thread2 拥有，因此 thread1 会陷入阻塞，而 thread2 醒来之后会去拿 lock1 ，但是 lock 在 thread1 手上，thread2 也会陷入阻塞， thread1 和 thread2 都进入了阻塞，相互等待，结果进入了死锁。

#### 2. 银行转账的案例 ####

具体案例可参考文章：[《银行转账（死锁）》][Link 1]

### 三、死锁发生的必要条件 ###

##### 1、互斥条件 #####

一个资源每一次`只能被一个`进程或者线程使用。比如我这里有锁，我拿了这锁之后，其他线程就不能拿到他，除非我释放了他

##### 2、请求与保持条件 #####

第一个线程请求第二把锁同时保持第一把锁。比如线程1想要请求一把锁B，在请求期间，他对已经拿到的锁A一直保持不释放

##### 3、不剥夺条件 #####

`不被外界干扰`剥夺锁。即没有外界干扰结束死锁的情况。

##### 4、循环等待条件 #####

两个或者多个互相等待或者环形`等待锁的释放`。比如两个线程等待条件，就是你等我释放，我等你释放；多个线程等待条件，就是A等B，B等C，C等D，D等E，E等F，F等A，无尽不释放，无尽陷入等待，构成环路。

***以上四个条件：缺一不可， 只需要破解以上4个条件任意一个条件，这个死锁就不会发生了！！***

### 四、如何定位死锁的位置 ###

#### 1、jstack 命令 ####

该代码来自文章[《银行转账（死锁）》][Link 1]中，代码如下：

public class TransferMoney implements Runnable {
    
        Integer flag = 1;
    
        static Account a = new Account(1000);
        static Account b = new Account(1000);
    
        //主函数
        public static void main(String[] args) throws InterruptedException {
            TransferMoney t1 = new TransferMoney();
            TransferMoney t2 = new TransferMoney();
            t1.flag = 1;
            t1.flag = 0;
    
            Thread thread1 = new Thread(t1);
            Thread thread2 = new Thread(t2);
    
            thread1.start();
            thread2.start();
            thread1.join();
            thread1.join();
            System.out.println("a的余额为："+a.balance);
            System.out.println("a的余额为："+b.balance);
        }
        
        @Override
        public void run() {
            if (flag == 1) {
                transferMoney(a, b, 500);
            }
            if (flag == 0) {
                transferMoney(b, a, 500);
            }
        }
        
        // 转账
        private void transferMoney(Account from, Account to, int amount) {
            synchronized (from) {
                System.out.println(Thread.currentThread().getName()+"获取到第一把锁");
                //加入线程睡眠500ms
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                synchronized (to) {
                    System.out.println(Thread.currentThread().getName()+"获取到第二把锁");
                    if (from.balance - amount < 0) {
                        System.out.println("余额不足，转账失败。");
                        return;
                    }
    
                    from.balance -= amount;
                    to.balance += amount;
                    System.out.println("成功转账" + i + "元");
                }
            }
        }
    
        static class Account {
            //余额
            int balance;
    
            public Account(int balance) {
                this.balance = balance;
            }
        }
    }

下面通过使用java自带的`jstack命令`，来查找我们项目中的死锁问题

## 需要首先获取程序的进程 pid
    jps
    ## 然后在 终端界面执行如下命令
    jstack 8359  #javahome下的jastack命令 进程的pid

执行结果图：

![ab45fb1e672f64493611246f5d37048c.png][]

可以清晰地看到 Thread-1 拿到了锁 <0x000000076adae688> ,正在等待 <0x000000076adae678>，而 Thread-0 拿到了锁 <0x000000076adae678>，正在等待 <0x000000076adae688>，于是两者互相等待，造成死锁。

#### 2、ThreadMXBean代码 ####

/**
     *      通过 ThreadMXBean 检测死锁
     */
    import java.lang.management.ManagementFactory;
    import java.lang.management.ThreadInfo;
    import java.lang.management.ThreadMXBean;
    
    public class ThreadMXBeanDetection implements Runnable{
        
        int flag = 1;//标记位
        static Object lock1 = new Object();
        static Object lock2 = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            ThreadMXBeanDetection r1 = new ThreadMXBeanDetection();
            ThreadMXBeanDetection r2 = new ThreadMXBeanDetection();
            r1.flag=1;
            r2.flag=0;
            Thread thread1 = new Thread(r1);
            Thread thread2 = new Thread(r2);
    
            thread1.start();
            thread2.start();
            Thread.sleep(1000);
    
            //得到实例
            ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
            long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
            //发现死锁
            if (deadlockedThreads != null && deadlockedThreads.length>0){
        
                //迭代
                for (long item : deadlockedThreads) {
        
                    //获取线程信息
                    ThreadInfo threadInfo = threadMXBean.getThreadInfo(item);
                    //获取死锁线程的名字
                    System.out.println("发现死锁："+threadInfo.getThreadName());
                }
            }
        }
    
        @Override
        public void run() {
        
            System.out.println("flag= " + flag);
            if (flag == 1) {
        
                synchronized (lock1){
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (lock2){
        
                        System.out.println(flag);
                    }
                }
            }
            if (flag == 0) {
        
                synchronized (lock2){
        
                    try {
        
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    synchronized (lock1){
        
                        System.out.println(flag);
                    }
                }
    
            }
        }
    }

打印结果：

![a164a401b6bc6768b4ab460a35dc3ce1.png][]

如上图所示，ThreadMXBean 可以检测死锁，如果我们检测到了之后，就可以编写对应的逻辑，比如重启线程、通知告警系统、发消息提醒运维人员等。

### 五、修复死锁策略 ###

#### 1、线上发生死锁应该怎么办 ####

`保存案发现场`，然后立即重启服务器，确保线上服务能运行下去，之后在利用保存的信息，排查死锁，`修改代码`，重新发布。

#### 2、常见修复策略 ####

*  **避免策略**：`哲学家就餐`的换手方案、转账换序方案。可参考下面两篇文章：
    
     *  [《哲学家就餐问题》][Link 2]
     *  [《银行转账》][Link 1]
 *  检测与恢复策略：一段时间`检测`是否有死锁，如果有就`剥夺`某一个资源，来打开死锁
    
     *  **检测算法**： 锁的调用链路图
        
         *  `允许`发生死锁
         *  每次调用锁的`记录`，并绘成一个有向的数据结构图
         *  定期检查`'锁的调用链路图'`中是否存在环路
         *  一旦发现死锁，就用死锁`恢复`机制恢复
     *  **死锁恢复机制**
        
         *  进程终止：`逐个终止`线程，直到死锁消除
            
             *  终止顺序：
                
                 *  线程的优先级（是前台交互还是后台处理）；
                 *  已占用资源多少、还需要的资源多少；
                 *  已运行时间长短
         *  资源抢占：
            
             *  把已经分发出去的锁`收回`
             *  让线程`回退让几步`，这样就不用结束整个线程，`成本比较低`
                
                 *  缺点：可能造成线程`饥饿`
 *  **鸵鸟策略**：鸵鸟这种动物在遇到危险的时候，通常就会把头埋在地上，这样一来它就看不到危险了。而鸵鸟策略的意思就是说，如果我们发生死锁的概率极其低，那么我们就直接`忽略`它，直到死锁`发生`的时候，再人工`修复`。这是一种消极的处理方式，不推荐。

### 六、如何在工程中避免死锁 ###

#### 1、设置`超时`时间 ####

*  由于 synchronized`不具备`尝试锁的能力，可以使用 Lock的`tryLock`(long timeout, TimeUnit unit) 替代。
 *  造成超时的可能性多：发生了死锁、线程陷入死循环、线程执行很慢，无论是哪种情况，只要过了超时时间，就认为失败
 *  获取锁失败的时候，要执行一些应对措施：比如打日志、发报警邮件、重启等

/**
     *      使用Lock中的tryLock()避免死锁
     */
    public class TryLockDeaLock implements Runnable {
        
        int flag = 1;
        static Lock lock1 = new ReentrantLock();
        static Lock lock2 = new ReentrantLock();
    
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                if (flag == 1){
        
                    try {
        
                        if (lock1.tryLock(800, TimeUnit.MILLISECONDS)){
        
                            System.out.println("线程1，拿到lock1");
                            Thread.sleep(new Random().nextInt(1000));
                            if (lock2.tryLock(800,TimeUnit.MILLISECONDS)){
        
                                System.out.println("线程1，成功获取到 lock1 & lock2");
                                //释放
                                lock2.unlock();
                                lock1.unlock();
                                break;
                            }else {
        
                                System.out.println("线程1，获取lock2，失败，已重试");
                                lock1.unlock();
                                Thread.sleep(new Random().nextInt(1000));
                            }
                        }else {
        
                            System.out.println("线程1，获取lock1，失败，已重试");
                        }
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                if (flag ==0){
        
                    try {
        
                        if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)){
        
                            System.out.println("线程2，拿到lock2");
                            Thread.sleep(new Random().nextInt(1000));
                            if (lock1.tryLock(3000,TimeUnit.MILLISECONDS)){
        
                                System.out.println("线程2，成功获取到 lock1 & lock2");
                                //释放
                                lock2.unlock();
                                lock1.unlock();
                                break;
                            }else {
        
                                System.out.println("线程2，获取lock1，失败，已重试");
                                lock1.unlock();
                                Thread.sleep(new Random().nextInt(1000));
                            }
                        }else {
        
                            System.out.println("线程2，获取lock2，失败，已重试");
                        }
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    
        //主函数
        public static void main(String[] args) {
        
            TryLockDeaLock t1 = new TryLockDeaLock();
            TryLockDeaLock t2 = new TryLockDeaLock();
            t1.flag = 1;
            t2.flag = 0;
            Thread thread1 = new Thread(t1);
            Thread thread2 = new Thread(t2);
    
            thread1.start();
            thread2.start();
        }
    }

#### 2、多使用`并发工具类`，而不是自己设计锁 ####

*  ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等
 *  实际应用中java.util.concurrent.atomic十分有用，简单方便且效率比使用Lock更高
 *  多用并发集合少用同步集合，并发集合比同步集合的可扩展性更好
 *  并发场景需要用到map，首先想到用ConcurrentHashMap

#### 3、尽量降低锁的使用粒度： ####

用不同的锁而不是一个锁

#### 4、如果能使用同步代码块，就不使用同步方法 ####

在代码块中，可以自己指定锁对象（方便掌控锁）

#### 5、给你的线程起个有意义的名字 ####

如果遇到问题，在debug和排查时事倍功半，更容易定位到问题，框架和JDK都遵守这个最佳实践

#### 6、避免锁嵌套 ####

比如下图中在已经持有 lock1 的情况下，还要继续请求 lock2，锁互相嵌套，更容易导致死锁

![dc90a798451f7d26f5af33282b5c9c57.png][]

#### 7、分配资源前先看能不能收回 ####

**银行家算法**：在放贷之前，首先对资源的进行有效计算，看看资源能不能收回来。

#### 8、不要几个功能用同一把锁 ####

每一个功能都要有自己专门的锁，专锁专用

### 七. 其它线程活跃性故障：活锁、饥饿 ###

死锁是最常见的活跃性问题，不过除了之前的死锁之外，还有一些类似的问题，会导致程序无法顺利执行，统称为 `活跃性问题`

#### 1. 活锁 ####

##### （1）什么是活锁 #####

*  虽然线程并没有阻塞，也`始终在运行`（所以被称为“活锁”，线程是“活的”），但是程序却得不到进展，因为线程始终重复做同样的事
 *  如果是死锁，只会是等待，不会消耗CPU资源，但活锁除了程序无法进行，还会消耗 cpu 资源

##### （2）代码演示 #####

可参考文章：[《牛郎织女的幸福生活》][Link 3]

##### （3）生产中的活锁：消息队列 #####

如果在消息队列中使用策略：消息处理失败，就放在队列开头`重试`。但是若该消息失败的原因是由于某个依赖的服务出了问题，会导致该消息一直失败。那么消息就会不停地重新放回队列头，不停地重试，虽然没阻塞，但是由于一直在处理该消息，程序也无法继续执行。

**解决方案：**

*  放到队列尾部
 *  设置重试次数限制

##### （4）活锁问题突破口 #####

增加随机因素：出现活锁的原因大都是因为重试机制不变，每一次重试的触发时机总是相同导致。所以可以参考以太网的指数退避算法：连接重试时间不是固定的，而是随机的，并且随机范围随着碰撞强度的升高而逐渐扩大。我们也可以加入一些随机因素，改变每次重试的条件或时机，或者每次重试的执行逻辑等。

#### 2. 饥饿 ####

##### （1）什么是饥饿 #####

*  当线程需要某些资源(例如CPU)，但是却一直`始终得不到`
 *  线程的`优先级`设置过低，或者有某个线程持有锁同时又无限循环从而`不释放锁`，或者某程序`始终占用`某文件的`写锁`

##### （2）饥饿的影响 #####

饥饿可能会导致`响应性差`：比如，我们的浏览器有一个线程负责处理前台响应（打开收藏夹等动作），另外的后台线程负责下载图片和文件、计算渲染等。在这种情况下，如果后台线程把CPU资源都占用了，那么前台线程将无法得到很好地执行，这会导致用户的体验很差

##### （3）解决方案 #####

*  **注意到程序上不应该有锁使用完却不释放的逻辑错误**
 *  **不应该在程序中设置优先级**

#### 文章来源：[死锁细究][Link 4] ####

### 个人微信：CaiBaoDeCai ###

### 微信公众号名称：Java知者 ###

### 微信公众号 ID： JavaZhiZhe ###

### 谢谢关注！ ###

[e3c92bf9cfcb4224c61680bdee7c3d62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/4261f49fbec34a10973557246f3c6122.png
[9f50e2478c4e08a8f31ca8414129c7be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/31588fe2985440e0a19457c52087ea9c.png
[a3f08d5b84414952cb5d1a7d75835bbb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/682dc82030124a4089bb11691d50e9e5.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzU3NDgyMTIxMw==&mid=2247484738&idx=3&sn=2640184c66abfbdc5054d6a252b8388c&chksm=fd2dc370ca5a4a66b2dec9d6a487139d7638a20a8452e959574ca46c7f64c606e3f83125a378#rd
[ab45fb1e672f64493611246f5d37048c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/4eff13f0b5c54f8b8aed7489d425f526.png
[a164a401b6bc6768b4ab460a35dc3ce1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/07ffa0c0d0b84a568db5a8d350d885b0.png
[Link 2]: https://mp.weixin.qq.com/s?__biz=MzU3NDgyMTIxMw==&mid=2247484738&idx=1&sn=cb51177d125a671fa1c5016fb8972f98&chksm=fd2dc370ca5a4a66bfe16466c1547e65e7781778abe42c08f5cff8ce13f0a3deac77015bcd8b#rd
[dc90a798451f7d26f5af33282b5c9c57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/99946b639ccd4344b0bbac6eeded730b.png
[Link 3]: https://mp.weixin.qq.com/s?__biz=MzU3NDgyMTIxMw==&mid=2247484738&idx=2&sn=ee1c2ecaaf49e258c969d049e9517920&chksm=fd2dc370ca5a4a66d23c4421d99b902c9ff90dd3f0fbac68f0834e5d597d53620eb12f08cdd6#rd
[Link 4]: https://mp.weixin.qq.com/s?__biz=MzU3NDgyMTIxMw==&mid=2247484739&idx=1&sn=37890dd583bc43ac34a324f81f1c13f8&chksm=fd2dc371ca5a4a670af6c47ada3ee631a002a93e12eb5944f1fb7b3ab02750dbcdf0260a6d7f#rd