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

GGBondlctrl 2024-10-02 12:05:01 阅读 100

前言:

🌈上期博客:【后端开发】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概念

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

<code> 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,那么然后在两个锁不进行释放的前提下,双方都想拿到对方的锁,此时就会发生死锁的情况;

这里有代码进行演示:

<code>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的获取:

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号哲学家吃完后,放下筷子,一次类推,可以保证每个哲学家都拿够吃到面~~~,同理这就解决了死锁这个问题;

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

<code>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内存可见性实例

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

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

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内存可见性原理

这里从核心指令入手:

<code>while (flag==0){

//不输出任何;

}

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

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

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

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

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

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

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

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

 4.3内存可见性解决

1.进行线程休眠

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

代码实现如下:

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核心作用:解决内存可见性问题,和禁止指令重排序~~~

代码演示:

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.总结

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

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


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

                                                               😊😊  期待你的关注~~~



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。