【JavaEE初阶】深入解析死锁的产生和避免以及内存不可见问题

前言:

🌈上期博客: 【后端开发】JavaEE初阶---线程安全问题与加锁原理(超详解)-CSDN博客

🔥感兴趣的小伙伴看一看小编主页:GGBondlctrl-CSDN博客

⭐️小编会在后端开发的学习中不断更新~~~

🥳非常感谢你的支持

目录

📚️1.引言

📚️2.可重入锁

2.1概念

2.2原理理解

📚️3.死锁

3.1产生死锁的情况

1.一个线程,一把锁

2.两个线程,两把锁

3.N个线程,M把锁

3.2解决死锁的方法

📚️4.内存可见性

4.1内存可见性实例

4.2内存可见性原理

4.3内存可见性解决

1.进行线程休眠

2.添加volatile关键词

📚️5.总结


📚️1.引言

OK啊!!!小伙伴们,本小编又带来了一个重磅知识,我们上期讲解了关于线程安全问题,引出了加锁这个概念;但是加锁会产生一个严重的问题,就是当我们运用不当时,进行加锁会导致死锁的发生,那怎样才会导致死锁呢?以及如何避免呢?这就是小编本期的重要内容;

发车发车gogogog~~~🥳🥳🥳;

且听小编讲解,包你学会!!!

📚️2.可重入锁

2.1概念

什么是可重入锁呢???,让我们看看以下代码:

java 复制代码
 public static void main(String[] args) {
        Object lock=new Object();
        //可重入锁实例
        Thread t1=new Thread(()->{
            synchronized (lock){
                synchronized (lock){
                    System.out.println("Hello thread");
                }
            }
        });
        t1.start();        
    }

对于如何进行加锁操作,小编上期有讲,不清楚的小伙伴可以自己去看看哦~~~

**开始认知:**这里由于lock已经被加过一次锁了,那么接下来再加一次锁,不会发生线程阻塞吗,第一次加又没有进行释放;

注意:上面这种理解完全是错误的,这里就是由于使用同一个线程,此时的锁对象,就能够知道第二次加锁的线程,是持有锁的线程,那么在第二次加锁时,就直接通过,就不会发生"阻塞"现象

这种特性叫:可重入性,这个锁就叫做可重入锁~~~

2.2原理理解

在Java中实现可重入锁是非常简单的,因为synchrinized自带这个特性,那么这个特性的内部原理是啥呢,且看如下图所示:

注意: 对于重入锁来说,最主要两部分第一个就是对于加锁的线程是否为同一个线程,第二就是对于加锁过程的计数器的次数理解;

以上都是在java中synchronized封装实现的,那么在C++中就没有重入锁的概念,此时当存在复杂的调用关系的时候,就会存在卡死的情况,就是"死锁",接下来就注重"死锁"的理解;

📚️3.死锁

在之前讲解过,加锁可以解决线程安全问题,但是操作不当会产生"死锁"的情况;

3.1产生死锁的情况

1.一个线程,一把锁

即在上述讲解过程中的可重入所情况,但是如果没有可重入这个性质,那么连续对一个线程加锁两次,那么就会产生死锁;

2.两个线程,两把锁

即有两个线程,当线程1加上锁A,线程2加上锁B,那么然后在两个锁不进行释放的前提下,双方都想拿到对方的锁,此时就会发生死锁的情况;

这里有代码进行演示:

java 复制代码
Object A=new Object();//对象A
        Object B=new Object();//对象B
        //创建线程t1拿到锁
        Thread t1=new Thread(()->{
            synchronized (A) {
                System.out.println("线程t1拿到了锁A");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException();
                }//线程进入休眠,保证另一个线程也能够拿到锁

                //尝试拿到对方的锁,此时锁A没有释放
                synchronized (B) {
                    System.out.println("线程t1拿到了两把锁");
                }
            }
        });

此时小编设置了两个对象,即两个锁对象,那么我们就进行线1的加锁,此时当我们拿到锁A后,在不解开锁的情况下进行另外一把锁B的获取:

java 复制代码
Thread t2=new Thread(()->{
            synchronized (B) {
                System.out.println("线程t2拿到了锁B");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException();
                }//线程进入休眠,保证另一个线程也能够拿到锁

                //尝试拿到对方的锁,没有释放自己的锁
                synchronized (A) {
                    System.out.println("线程t2拿到了两把锁");
                }
            }
        });

此时,我们就行第二个线程的实现,和上述线程1一样,当拿到自己的锁之后,在不解开锁的情况下进行锁A的获取,然后两个线程启动之后的结果就是:

此时可以发现,线程各自拿到自己的锁之后,就直接"卡住"了,这就发生了线程安全问题;

当我们打开jconsole后,可以看看我们的线程情况:

这是我们的两个对应的线程名字,此时两个线程的执行状态就如下图所示:

注意: 此时可以看到线程1处于BLOCKED状态,并且在等锁B,那么锁B的拥有者是线程2;同理,线程2在等锁A,而锁A的拥有者就是线程1;

可以发现此时两个锁都在等对方释放锁,此时就产生了死锁;

3.N个线程,M把锁

此时这种情况就是要考虑到"哲学家就餐问题了",什么是哲学家就餐问题呢???

解释: 此时有5个哲学家要吃面,但是筷子只有5根,这无根筷子在每个哲学家之间,此时就是五个哲学家就是五个线程,筷子就是锁,当每个哲学家拿到筷子后,旁边的两哲学家是吃不到的,就处于阻塞的状态,一般情况下哲学家啥时候吃到面是一个随机问题,一般情况下这是没有问题的~~~

注意: 当我们每个哲学家左手拿起筷子时,可以发现此时每个哲学家都吃不到面(吃面要两根筷子),都等待另一个哲学家释放筷子(锁),此时就发生了线程的阻塞 ;

3.2解决死锁的方法

在了解线程的解决死锁之前我们要知道产生死锁的必要条件

(重点)

1.互斥使用:当一个线程获取到锁之后,另一个线程也想要获取,那么此时就要进行阻塞

2.不可抢占:当一个线程获得锁之后,其他线程想要获取此时就要等到锁的释放,不能强行占用

3.请求保持:当一个线程获得锁A之后,尝试再次获取锁B(锁A是没有释放的)

4.循环等待/环路等待

以上就是死锁形成的必要条件,缺一不可~~~;

那么针对以上死锁的产生条件,第三个条件是根据具体的代码来进行实现的,但是我们可以根据最后一个来进行攻破;

注意: 解决哲学家问题关键:针对五把锁我们可以对其进行编号,然后每个哲学家也进行编号,此时约定,每个哲学家开始只能够拿编号比自己小的锁,然后再拿比自己编号大的锁;

为啥能够解决死锁问题呢???且看下图所示:

**过程解释:**当我们为这个线程和锁进行编号后,此时由于只能拿比自己编号小的筷子,那么2号哲学家拿1筷子,3号哲学家拿2号筷子.......到最后,5号哲学家拿4号筷子,此时就可以发现多了一双筷子,那么5号哲学家先再拿起5号筷子,此时当5号哲学家吃完后,放下筷子,一次类推,可以保证每个哲学家都拿够吃到面~~~,同理这就解决了死锁这个问题;

那么此时我们就可以改变之前这个双方获取两个锁的这个代码,实现这个代码的可行性:

java 复制代码
Thread t2=new Thread(()->{
            synchronized (A) {
                System.out.println("线程t2拿到了锁A");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException();
                }//线程进入休眠,保证另一个线程也能够拿到锁

                //尝试拿到对方的锁,没有释放自己的锁
                synchronized (B) {
                    System.out.println("线程t2拿到了两把锁");
                }
            }
        });

注意:这里小编只改了第二个线程的获取锁的顺序,即可保证两个线程都能够拿到锁;

解析: 这里能够执行原因:当两个线程启动的时候,线程1获取到了锁A,所以此时线程B规定先不获取锁,即他以获取锁A来发生阻塞,当线程1执行完后,线程2就能够得到两个线程了~~~,这就是引入了加锁顺序规则~~~

总结:

解决死锁有很多办法,以下是一些小编总结的一些方法:

1.添加"筷子";

2.去掉一个线程

3.引入计数器,规定最多同时几个人吃面

4.引入加锁顺序规则

5."银行家算法"

1~3:虽然能够解决这个问题,但是普适性不高;

4:是小编推荐的,普适性高,而且容易实现;

5:是可以解决这个死锁问题,但是不推荐,实现过程很复杂,理论成立,现实不行;

📚️4.内存可见性

4.1内存可见性实例

内存可见性问题:即一个程序读,一个程序写的过程中产生的线程安全问题;

小编就用代码实例来演示:

java 复制代码
public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while (flag==0){
                //不输出任何;               
            }
                System.out.println("flag的值进行了改变");
        });
        Thread t2=new Thread(()->{
            System.out.println("输入一个flag的值");
            Scanner scanner=new Scanner(System.in);
            flag=scanner.nextInt();
        });
        //起启动线程
        t1.start();
        t2.start();
    }

**解释:**此时我们规定线程1进行读的操作,若flag是0,那么就不会打印任何日志,此时小编在线程2上进行改变,线程1中flag的值,让其不满足条件,实现跳出循环,结束线程;但是输出如下:

可以发现在小编输入1,改变flag的值之后,回车并没有输出"flag的值进行了改变",所以此时就发生了线程安全问题,即内存可见性问题~~~

4.2内存可见性原理

这里从核心指令入手:

java 复制代码
while (flag==0){
   //不输出任何;               
}

注意:这里的核心指令有两条

1.load读取内存当中的指令到寄存器中

2.寄存器拿着值与0进行比较

那么此时就是在线程2启动到输入这个操作,不断进行循环读取,比较的过程,所以这个操作有两个关键要点:

1.load不断从内存中读取数据到CPU寄存器上,这个操作的执行结果是一样的,几秒之内已经很多次了~~~

2.load从内存中读取数据这个操作开销远远大于寄存器比较这个操作~~~

此时就出现了一个问题:编译器优化代码这个操作,即JVM在优化中发现读取数据操作一直不变,那么优化后即将这个load读取数据操作给省去了(关键原因);

**代码优化:**即JVM在保持原有代码逻辑不变的情况下,实现提高代码的效率,单线程还好,但是多线程很容易发生误判~~~

4.3内存可见性解决

1.进行线程休眠

**核心:**在上述讲解中,是因为读取这个内存的次数过多,且没有改变,所以我们能够实现,读取次数减少的操作;

代码实现如下:

java 复制代码
Thread t1=new Thread(()->{
            while (flag==0){
                //不输出任何;
                try {
                    Thread.sleep(1000);
                }
                catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
                System.out.println("flag的值进行了改变");

        });

小编只需要在读取数据这个操作实现休眠即可;

注意:这里的休眠是为了减少从内存中读取数据到CPU寄存器上,让load开销减少,减少迫切优化的程度;此时JVM就不会进行优化了,那么就不会出现线程安全问题

2.添加volatile关键词

**volatile作用:**这里的volatile关键词会阻止JVM对程序进行优化,确保每次循环都会从内存中读取数据到寄存器当中~~~

volatile核心作用:解决内存可见性问题,和禁止指令重排序~~~

代码演示:

java 复制代码
public  volatile static int flag=0; //加上volatile实现代码优化的消除
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            while (flag==0){
                //不输出任何;                
            }
                System.out.println("flag的值进行了改变");

        });

注意:volatile和上述休眠作用基本一致,都是使JVM优化程序关闭,保证每次循环都是从内存中读取数据,而不是优化成直接从寄存器当中读取数据~~~

📚️5.总结

💬💬本期小编总结了关于多线程的重要知识即死锁,分别从造成原因和如何进解决提出了关于小编的理解,以及线程安全问题之内存可见性问题,并附上了代码供小伙伴们参考参考~~~

🌅🌅🌅~~~~最后希望与诸君共勉,共同进步!!!


💪💪💪以上就是本期内容了, 感兴趣的话,就关注小编吧。

😊😊 期待你的关注~~~

相关推荐
----云烟----1 分钟前
QT中QString类的各种使用
开发语言·qt
lsx2024066 分钟前
SQL SELECT 语句:基础与进阶应用
开发语言
小二·7 分钟前
java基础面试题笔记(基础篇)
java·笔记·python
开心工作室_kaic30 分钟前
ssm161基于web的资源共享平台的共享与开发+jsp(论文+源码)_kaic
java·开发语言·前端
向宇it32 分钟前
【unity小技巧】unity 什么是反射?反射的作用?反射的使用场景?反射的缺点?常用的反射操作?反射常见示例
开发语言·游戏·unity·c#·游戏引擎
懒洋洋大魔王32 分钟前
RocketMQ的使⽤
java·rocketmq·java-rocketmq
武子康37 分钟前
Java-06 深入浅出 MyBatis - 一对一模型 SqlMapConfig 与 Mapper 详细讲解测试
java·开发语言·数据仓库·sql·mybatis·springboot·springcloud
转世成为计算机大神1 小时前
易考八股文之Java中的设计模式?
java·开发语言·设计模式
宅小海1 小时前
scala String
大数据·开发语言·scala
qq_327342732 小时前
Java实现离线身份证号码OCR识别
java·开发语言