【线程安全】死锁问题及解决方案

柔情只为你懂 2024-03-26 16:02 88阅读 0赞

## 1. 什么是死锁 ##

比如上一次讲到 synchronized 的时候，一个线程，对同一个对象连续加锁两次，如果出现阻塞等待，代表这个锁是不可重入锁，这样的线程，也就称为死锁！

一旦程序进入死锁了就会导致线程僵住了，无法继续执行后续的工作了，程序也就出现了严重的 BUG！

而死锁这样的情况是很隐蔽的，在开发阶段，不经意间就可能出现死锁的状态！

## 2. 死锁的三个典型情况 ##

### 2.1 一个线程一把锁 ###

一个线程，对同一个对象，重复加锁两次，如果不支持可重入，即会出现死锁现象，但是在 Java 中，synchronized 和 ReentarntLock(后面讲) 都是支持可重入的！

所以在 Java 中，也就不会出现这样的情况，但不排除在其他语言会出现这种情况。

### 2.2 两个线程两把锁 ###

**举一个生活中的例子来让大家更好的理解：**

有一天张三和小美是俩社恐人员，他俩去吃牛排，由于小美吃不了太多，于是他俩就点了一份牛排，服务员只给了一个刀和叉，此时张三一把夺过刀，小美一把夺过叉，此时小美对张三说，你先把刀给我，我吃一口就给你，张三说不行，你先把叉子给我，我吃一口再给你，于是这样她俩谁都不让着谁，导致谁都吃不上牛排了！

![4d588f51e97141eab44966c1aa6ce42f.png][]

如果把上述例子放在编程中，就比如张三和小美是两个线程，张三获取到对象A的锁，小美获取到对象 B 的锁，但是他俩还尝试获取对方的锁！

**用代码表示如下：**

public static void main(String[] args) {
        Object knife = new Object(); //刀
        Object fork = new Object(); //叉
        Thread t1 = new Thread(() -> {
            synchronized (knife) {
                System.out.println("张三拿到刀了!");
                synchronized (fork) {
                    System.out.println("张三刀和叉都拿到了!吃牛排!");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (fork) {
                System.out.println("小美拿到叉了!");
                synchronized (knife) {
                    System.out.println("小美刀和叉都拿到了!吃牛排!");
                }
            }
        });
        t1.start();
        t2.start();
    }

**打印结果：**

![36e84cf4bd4e451bb97150e2e8ecb992.png][]

此时就发现，代码僵住了，其实也就是 t1 在等 t2 释放锁，而 t2 也在等 t1 释放锁，此时两个线程都无休止的阻塞等待下去了，最终导致，张三拿不到刀叉，小美也拿不到刀叉！都不吃成牛排了！

**上述代码的写法是有小概率让张三同时拿到刀和叉的，这个取决于 CPU 的调度。**

这里可以通过 jconsole 工具来查看一下线程的情况：

![213dbe1bea8f4701b6a23f902306c136.png][]

这里发现线程进入了 BLOCKED 状态，前面讲解线程状态的时候说过，BLOCKED 状态是等待锁时产生的状态，当然也可以给上述代码添加获取线程状态的方法，也能发现是 BLOCKED 状态：

Thread.sleep(1000); // 保证进入阻塞状态
    System.out.println(t1.getState()); // 查看t1线程状态
    System.out.println(t2.getState()); // 查看t2线程状态

![5c75acb64ca6458394272c572f1a672c.png][]

### 2.3 多个线程多把锁 ###

多个线程多把的情况跟上述 2.2 的情况差不多，相当于是 2.2 的一般情况！

**在很多资料上有一个典型的案例 "哲学家就餐问题" ！**

有一个桌子，围着一圈哲学家，每个哲学家面前放着一碗面，哲学家两两之间放**一只**筷子，而桌子上的哲学家只会做两件事：**吃面**(获取到锁，执行后续代码)或者**思考人生**(阻塞等待)。

当哲学家吃面的时候，就会拿起左右手的筷子(先拿左边，再拿右边)，当哲学家思考人生的时候，就会放下左右手的筷子。

![3821c69c313f4d698c7535d9e2099333.png][]

如果哲学家拿到两根筷子了，就会吃面，没拿到就会思考人生！

**极端情况来了！**如果五个哲学家同时都拿起左手边的筷子，接着每个人都去拿自己右手边的筷子，发现右边的筷子都被别人拿走了！都要等右边的哲学家把筷子放下，此时就僵住了！由于哲学家们互不相让，此时也就形成了死锁的现象。

--------------------

## 3. 如何避免死锁 ##

### 3.1 产生死锁的四个必要条件 ###

**互斥使用：**当 t1 线程拿到了锁，t2 如果也想拿，必须等着，等 t1 释放了(锁的基本特性)

**不可抢占：**t1 拿到了锁，必须由 t1 主动释放，t2 不能强行获取锁！

**保持和请求：**t1 拿到了锁 A，再拿到了 B 的锁，此时 A 这把锁还是保持的(不会因为获取到了锁 B 就把 锁 A 给释放了)

**循环等待：**当 t1 尝试获取锁A和B，t2也尝试获取锁B和A，如果 t1 获取到锁A，t2 获取到锁B，此时 t1 就会等待 t2 释放锁B，而 t2 也会等待 t1 释放锁 A

所以只要打破这四条的任意一条，就能让死锁消失，但前三条对于 synchronized 来说，都是基本的特性，修改不了，而循环等待上述唯一一个和代码结构相关的，也是咱们可以控制的！

**所以解决死锁最简单可靠的办法，就是打破循环等待！**

### 3.2 打破循环等待 ###

如何打破循环等待呢？就比如上述张三和小美吃牛排的问题！

张三一把夺过刀，小美一把夺过叉，于是张三想了个公平的办法，对小美说："这样的情况，我们都吃不到牛排，我们做个约定吧，把刀叉一起放着，数到一就一起抢，但是有一个抢的顺序，只能先刀在抢叉"。

**这就好比对刀和叉进行了编号，约定好，想要拿刀叉，可以，但是必须先拿刀，后拿叉！**

于是张三数到一，一瞬间张三抢到了刀，此时小美没有抢到刀，由于前面的约定，小美只能等张三放下刀了，于是张三就顺利吃到了牛排！

**代码实现：**

public static void main(String[] args) throws InterruptedException {
        Object knife = new Object(); //刀
        Object fork = new Object(); //叉
        Thread t1 = new Thread(() -> {
            // 先对刀加锁, 才能对叉加锁
            synchronized (knife) {
                System.out.println("张三拿到刀了!");
                synchronized (fork) {
                    System.out.println("张三刀和叉都拿到了!吃牛排!");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            // 先对刀加锁, 才能对叉加锁
            synchronized (knife) {
                System.out.println("小美拿到刀了!");
                synchronized (fork) {
                    System.out.println("小美刀和叉都拿到了!吃牛排!");
                }
            }
        });
        t1.start();
        t2.start();
    }

打印结果：

![5e5dd6dba3c542319d8fe8562827208c.png][]

做了约定之后(对锁编号)，此时死锁的问题就迎刃而解了！

那么对于哲学家吃面的问题，也是如此，对每根筷子进行编号，约定好，只能先拿左右手编号小的筷子，再拿编号大的筷子。

![616c62b3fd8e4140ac90dc70bade04de.png][]

此时这样一来，总有一个人拿不到筷子，那么上述情况，拿到编号为 4 筷子的哲学家就能拿编号为 5 筷子吃面了，吃完了放下两支筷子，接着右手边拿到 3 筷子的哲学家就拿起放下的 编号4 筷子进行吃面了，以此类推.....

**本质上我们这里讲的避免死锁的方案，就是约定加锁顺序！约定顺序后，死锁的问题就解决了！也就打破了第四点的循环等待！**

其实还有一种算法，银行家算法， 但实际开发中不推荐使用，比起上述讲的办法银行家算法更复杂，也更容易出错，所以更推荐上述约定顺序的方法！

如果对银行家算法感兴趣的，可以自行查阅下相关资料！

--------------------

**下期预告：【多线程】volatile 关键字**

[4d588f51e97141eab44966c1aa6ce42f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/8a8b9d9b6f3a44839e5a1eba790eecdf.png
[36e84cf4bd4e451bb97150e2e8ecb992.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c0232d0658374a27ad4556a8c640f23e.png
[213dbe1bea8f4701b6a23f902306c136.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2dd258bf9a3f448f8b097f7307ae9d0d.png
[5c75acb64ca6458394272c572f1a672c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/282e96551e3f4086a88a08d4f820c19f.png
[3821c69c313f4d698c7535d9e2099333.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e7c46b9ef0854c2b80ec3a9cdf947385.png
[5e5dd6dba3c542319d8fe8562827208c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/825361cbe2db487fbb6d22753bde2069.png
[616c62b3fd8e4140ac90dc70bade04de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/61651c3cdcbb49728ac3bda1df8102cc.png