高并发编程之死锁

这个名字先用着

已于 2022-03-30 17:36:57 修改

阅读量408

点赞数

分类专栏：多线程面试文章标签：霍夫曼树数据结构哈希算法

于 2022-03-05 17:25:52 首次发布

本文链接：https://blog.csdn.net/weixin_38568503/article/details/123297748

版权

面试同时被 2 个专栏收录

56 篇文章 5 订阅

订阅专栏

多线程

35 篇文章 4 订阅

订阅专栏

死锁的概念：

死锁是指两个或两个以上的进程（线程）在执行过程中，由于争夺资源或者由于彼此通信而造成的一种互相等待的阻塞现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态：
在这里插入图片描述

在这里插入图片描述

死锁产生的4个必要条件：

1.互斥：某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。
2. 占有且等待：一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
3. 不可抢占：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
4. 循环等待：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。

当以上四个条件均满足，必然会造成死锁，发生死锁的进程无法进行下去，它们所持有的资源也无法释放。这样会导致CPU的吞吐量下降。所以死锁情况是会浪费系统资源和影响计算机的使用性能的。那么，解决死锁问题就是相当有必要的了。

形成死锁的四个必要条件是什么:

互斥：线程(进程)对于所分配到的资源具有排它性，即一个资源只能被一个线程(进程)占用，直到被该线程(进程)释放
请求与保持：一个线程(进程)因请求被占用资源而发生阻塞时，对已获得的资源保持不放。
不剥夺：线程(进程)已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
循环等待：当发生死锁时，所等待的线程(进程)必定会形成一个环路（类似于死循环），造成永久阻塞

在这里插入图片描述

代码演示死锁：

下面通过一个例子来说明线程死锁：

package com.fan.lock;
import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    //创建两个对象,用作锁
     static Object a = new Object();//资源a
     static Object b = new Object();//资源b
    public static void main(String[] args) {
        new Thread(()->{
            //要运行的任务
            synchronized (a){//占有锁a
                System.out.println(Thread.currentThread().
                        getName()+"持有锁a（资源a）,试图获取锁b");

                /*占有且等待:
                *  一个进程本身占有资源（一种或多种），
                * 同时还有资源未得到满足，正在等待其他进程释放该资源*/
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){//申请获取锁b,在没有释放锁a的情况下
                    System.out.println(Thread.currentThread().
                            getName()+"获取锁b...");//由于产生死锁，无法打印出结果
                }
            }//自动释放外层synchronized的锁a
        },"线程A").start();
        //创建线程B
        new Thread(()->{
            //要运行的任务
            synchronized (b){//占有锁b
                System.out.println(Thread.currentThread().
                        getName()+"持有锁b（资源b）,试图获取锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){//申请获取锁a，在没有释放锁b的情况下
                    System.out.println(Thread.currentThread().
                            getName()+"获取锁a...");//由于产生死锁，无法打印出结果
                }
            }//自动释放外层synchronized的锁b
        },"线程B").start();
    }
}

在这里插入图片描述

线程 A 通过 synchronized (a) 获得 a资源的监视器锁，然后通过TimeUnit.SECONDS.sleep(1)；让线程 A 休眠 1s 为的是让线程 B 得到CPU执行权，然后获取到 b 资源的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。

如何避免线程死锁:

我们只要破坏产生死锁的四个条件中的其中一个就可以了。

破坏互斥条件

这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。

破坏请求与保持条件

一次性申请所有的资源。

破坏不剥夺条件

占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。

破坏循环等待条件

靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

检测死锁的方式一：通过jdk工具jps、jstack：

在这里插入图片描述

第一步：在可能发生死锁的类中，右键选择show in explorer（在资源管理器中显示）–>然后到文件夹中，选中路径，输入cmd
在这里插入图片描述

在这里插入图片描述

第二步：回到idea的Terminalh窗口，输入命令jps -l
然后找到自己的可能发生死锁类的进程号，然后jstack 进程号

Terminal相当于cmd窗口:
在这里插入图片描述

在这里插入图片描述

第一步好像可以不用，自己测试了一下。

检测死锁的方式二：通过jdk提供的工具jconsole

①在java的cmd窗口terminal中输入jconsole：
在这里插入图片描述

②选择自己写的可能发生死锁的类，点击连接

在这里插入图片描述

在这里插入图片描述
③选择线程，点击底部的检测死锁即可：

在这里插入图片描述

检测死锁的方式三：通过jdk提供的工具VisualVM

VisualVM：jdk提供的一个非常强大的排查java程序问题的一个工具，可以监控程序的性能、查看jvm配置信息、堆快照、线程堆栈信息。算是程序优化的必备工具。

工具位于jdk的bin目录中。
在JDK1.6后的版本是自带这个工具，它就在你的jdk的bin目录上
如果是默认安装的JDK，一般就在C盘，Program Files的java目录，就会看到你的jdk版本，点进去之后打开bin这个文件夹，就可以看到这个软件了

jdk8之后的版本，jdk工具包中不带有visualvm工具，因此需要我们自行下载

1、下载：

地址：https://visualvm.github.io/index.html

下载独立版
在这里插入图片描述

在这里插入图片描述

2、下载完成后解压

3、配置JDK路径：
加入JDK 路径

visualvm_jdkhome=""

4、双击bin目录下的visualvm.exe打开

在这里插入图片描述

jdk1.6自带的使用： jvisualvm

如何避免死锁？

我们知道了死锁如何产生的，那么就知道该如何去预防。如果一个线程每次只能获取一个锁，那么就不会出现由于嵌套持有锁顺序导致的死锁。

1. 正确的顺序获得锁

如果必须获取多个锁，我们就要考虑不同线程获取锁的顺序，

上面的例子出现死锁的根本原因就是获取锁的顺序是乱序的，超乎我们控制的。上面例子最理想的情况就是把业务逻辑抽离出来，把获取锁的代码放在一个公共的方法里面，让这两个线程获取锁都是从我的公共的方法里面获取。

2. 超时放弃

当线程获取锁超时了则放弃，这样就避免了出现死锁获取的情况。当使用synchronized关键词提供的内置锁时，只要线程没有获得锁，那么就会永远等待下去，然而Lock接口提供了boolean tryLock(long time, TimeUnit unit) throws InterruptedException方法，该方法可以按照固定时长等待锁，因此线程可以在获取锁超时以后，主动释放之前已经获得的所有的锁。通过这种方式，也可以很有效地避免死锁。

总结
死锁就是“两个任务以不合理的顺序互相争夺资源”造成，因此为了规避死锁，应用程序需要妥善处理资源获取的顺序。另外有些时候，死锁并不会马上在应用程序中体现出来，在通常情况下，都是应用在生产环境运行了一段时间后，才开始慢慢显现出来，在实际测试过程中，由于死锁的隐蔽性，很难在测试过程中及时发现死锁的存在，而且在生产环境中，应用出现了死锁，往往都是在应用状况最糟糕的时候——在高负载情况下。因此，开发者在开发过程中要谨慎分析每个系统资源的使用情况，合理规避死锁。