【JavaEE 初阶（二）】线程安全问题

devtools/2024/10/18 14:25:07/

❣博主主页: 33的博客❣
▶️文章专栏分类:JavaEE◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多线程知识

在这里插入图片描述

目录

  • 1.前言
  • 2.synchronized
    • 2.1例子
    • 2.2synchronized修饰代码块
    • 2.3 synchronized修饰方法
    • 2.4synchronized特性
  • 3.死锁
    • 3.1死锁的成因
    • 3.2解决死锁
  • 4.volatile
    • 4.1内存可见性问题
    • 4.2volatile解决
  • 5.wait与notify
    • 5.1wait
    • 5.2notify
  • 6.总结

1.前言

在上一篇文章中，我们已经初步认识了线程的一些知识，但线程中一个重要问题就是线程安全问题，这篇文章我们就来了解为什么会引起线程安全问题，已经解决方法，有些代码在单个线程中执行是完全正常的，不会出现bug，但同样的代码，让多个线程，同一时间执行那么就可能出现bug，这就称为线程安全问题。

2.synchronized

2.1例子

例：我们让两个线程同时执行cou++操作，各自增5w，预期结构应该为10w，我们通过代码来观察是否符合预期结果。

java">public class Demo11 {public static int count=0;public static void main(String[] args) throws InterruptedException {Object lock=new Object();//Object lock2=new Object();Thread t1=new Thread(()->{for (int i=0;i<50000;i++){                count++;             }});Thread t2=new Thread(()->{for (int i=0;i<50000;i++){count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);}
}

观察结果：
在这里插入图片描述
我们多次运行发现发现每次count的结尾都不等于10w，并且每次都不同。
出现这样的原因是为什么呢？其实是因为在执行cou++操作的时候有3步操作

load 把数据从内存读到cpu中
add 把寄存器+1
save 把寄存器中的数据保存到内存中
那么两个进程同时执行就会出现多种方式：
在这里插入图片描述
博主列出的只是部分执行情况，实际情况还有更多
在正确情况下：
在这里插入图片描述
错误情况下：
在这里插入图片描述
我们就可以知道线程安全的原因：
1.操作系统种线程的调度是随机的
2.两个线程对于同一个变量进行修改
3.修改操作不是原子性的
4.内存可见性问题
5.指令重排序问题
如果要想解决线程安全问题，就可以使修改操作变为原子性的，那么怎么变为原子性的呢？加锁操作。
最常见的加锁方法就是synchronized关键字。

2.2synchronized修饰代码块

在使用synchronized时，要搭配一个代码块{}进入{就会加锁，出了}就会解锁，我们用代码进行实现。
在这里插入图片描述
我们发现synchronized（）报错，是因为（）中需要表示一个用来加锁的对象，这两个对象是啥并不重要，重要的是通过这个对象来区分两个线程是否在竞争同一个锁，如果两个线程在针对同一个对象加锁就会出现锁竞争，那么由于锁的竞争，只有等一个线程解锁后，另一个线程才能再进行count++操作。

java">public class Demo11 {public static int count=0;public static void main(String[] args) throws InterruptedException {Object lock=new Object();//Object lock2=new Object();Thread t1=new Thread(()->{for (int i=0;i<50000;i++){synchronized (lock){count++;}}});Thread t2=new Thread(()->{for (int i=0;i<50000;i++){synchronized (lock){count++;}}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+count);}
}

2.3 synchronized修饰方法

synchronized除了修饰代码块以外还可以修饰方法

java">class cunter{int count;public synchronized void count (){//相当于synchronized(this){}count++;}
//修饰静态方法
//    public static synchronized void count2 (){//相当于synchronized(cunter.class){}
//        count++;
//    }
}
public class Demo12 {public static void main(String[] args) throws InterruptedException {cunter counter=new cunter();Thread t1=new Thread(()->{for (int i=0;i<50000;i++){counter.count();}});Thread t2=new Thread(()->{for (int i=0;i<50000;i++){counter.count();}});t1.start();t2.start();t1.join();t2.join();System.out.println("count="+counter.count);}
}

synchronized用的锁存在java对象头里面的，在一个java对象中，除了自己定义的属性和方法，还有一些自带的属性，这些自带的属性就称为对象头，其中就有属性表示当前对象是否加锁。

2.4synchronized特性

synchronized特性

1.互斥：某一个线程a如果执行某个某个对象的加锁操作时，如果其他线程也想给同一个对象加锁，那么就要 等a执行完成b才能实现加锁操作。
2.可重入：1个线程中，synchronized 代码块中针对同一把锁加锁多次，不会出现“死锁”问题。

java">public class Demo15 {public static void main(String[] args) {Object lock=new Object();Thread t1=new Thread(()->{synchronized (lock){synchronized (lock){System.out.println("t1");}}//（1）});//(2)t1.start();}
}

上诉代码，在t线程如果第一次的lock加锁成功，又遇到了一个lock操作，但只有等第一次}(2)de的位置解锁才能执行加锁操作，可是如果使}（2）执行完，就需要先执行加锁操作，这样就导致代码一直注释，没有办法释放锁。所以就把synchronized设置为了“可重入锁”就解决了上述问题。
但此时又有了新的问题，如果在一个线程中，对一把锁多次加锁，那么在什么时候才释放锁呢？

java">public class Demo15 {public static void main(String[] args) {Object lock=new Object();Thread t1=new Thread(()->{synchronized (lock){synchronized (lock){synchronized (lock){synchronized (lock){synchronized (lock){}}}}}});t1.start();}
}

要在这个线程的最外层才能释放锁，在锁对象中，不仅会记录是谁拿到了锁，还会记录加锁了多少次，每加锁一次，计数器++，解锁一次，计数器–，直到最后一个大括号结束。

3.死锁

在上述代码中，我们已经提到过死锁了，在1个线程中，针对一把锁连续加锁两次，如果是不可重入，就会出现死锁了。
如果是两个线程，两把锁（无论是不是可重入，都会死锁）
例如：(1)t1获取锁A，t2获取锁B (2)t1获取锁B,t2获取锁A

java">public class Demo13 {public static void main(String[] args) {Object lock1=new Object();Object lock2=new Object();Thread t1=new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t1线程");}}});Thread t2=new Thread(()->{synchronized (lock2){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock1){System.out.println("t2线程");}}});t1.start();t2.start();}
}

在t1线程，lock1锁中在等待lock2锁解锁，但此时lock2也在等待lock1解锁，此时会会两个线程一直僵持下去。
N个线程M把锁：哲学家问题
有5个哲学家坐在一起吃饭，但只有5根筷子，哲学家就只做两件事情，一件事情为思考，另一件事情就是吃饭，当其中一个哲学家要吃饭时，就会拿起左右两边的筷子，那么此时如果左右相邻的哲学家也想吃饭时，就需要等待正在吃饭的哲学家吃完饭，放下筷子，才能继续吃，在通常情况下，整个系统可以很好的运转，但是当5个哲学家同时拿起左边的筷子时，就会出现死锁问题.
在这里插入图片描述
死锁是一种严重的bug那么该如何解决死锁问题呢？我们就需要先了解死锁的成因。

3.1死锁的成因

1.互斥使用（锁的基本特性）：当一个线程有一把锁时，另一个线程也想获取同一把锁就要阻塞等待。
2.不可抢占（锁的基本特性）：当线程a拿到锁时，只有等线程a解除锁，线程b才能再使用。
3.请求保持：一个线程尝试获取多把锁
4.循环等待：等待的依赖关系形成了环。

3.2解决死锁

互斥和不可抢占性都是锁的基本特性，我们可以通过代码的结果来来避免写成“嵌套锁”但这个方案不一定好使，有的需求可能就是需要进行这种嵌套操作，所以我们最好
针对循环来解决，可以约定加锁条件避免形成循环等待，针对锁，约定加多把锁的时候，现加编号小的锁，再加编号大的锁并且所有线程都要遵守这一规则。

java">public class Demo13 {public static void main(String[] args) {Object lock1=new Object();Object lock2=new Object();Thread t1=new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t1线程");}}});Thread t2=new Thread(()->{synchronized (lock1){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lock2){System.out.println("t2线程");}}});t1.start();t2.start();}
}

4.volatile

4.1内存可见性问题

计算机运行程序，经常要访问数据，这些数据往往存储在内存中，cpu使用这些变量的时候，要先从内存中读取数据，再对数据进行操作，cpu读取内存相对来说是非常慢的，cpu执行大部分操作都是非常快的，但一旦涉及到读取内存操作，就非常慢。为了解决上诉问题，此时编译器就可能对代码进行优化，把一些本来要读取内存的操作优化为读取寄存器，减少内存的读取次数就大大提高了程序的效率。
例：

java">public class Demo14 {public static int isQuit=0;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{while (isQuit==0){}System.out.println("t1进程结束");});t1.start();Thread.sleep(1000);System.out.println("请输入isQuit");Scanner scanner=new Scanner(System.in);isQuit= scanner.nextInt();}
}

预期效果是当过了1s中后，输入isQuit为1，应该结束循环，输出t1进程结束。
我们来看一看实际结果：
在这里插入图片描述
很明显，实际结果和预期结果不一样，之前是两个进程修改同一个变量引起的bug，但现在是一个线程修改，另一个线程读，同样也引起了bug，是什么原因呢？
在t1线程中读取isQuit的值到寄存器中，通过cmp指令比较寄存器的值是否为0，由于这个循环执行的飞快，就需要多次从内存中load，再cmp，此时编译器就发现虽然进行了这么多次load但是load出来的结果没有任何变化，所以编译器就做了一个大胆的决定！只是第一次寻黄的时候读取内存，此后直接从寄存器中读取isQuit的值。它的初心虽然是好的，但是我此后如果修改了isQuit的值，但t1寄存器读取的仍然是isQuit修改前的值就出现了bug。这个问题就称为“内存可见性”问题。

4.2volatile解决

在多线程环境下，编译器对是否要进行优化的判定不一定准就需要通过volatile关键字告诉编译器我不需要优化！！！！

java">import java.util.Scanner;
public class Demo14 {public static volatile  int isQuit=0;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{while (isQuit==0){}System.out.println("t1进程结束");});t1.start();Thread.sleep(1000);System.out.println("请输入isQuit");Scanner scanner=new Scanner(System.in);isQuit= scanner.nextInt();}
}

此时就可以结束线程1了：
在这里插入图片描述

5.wait与notify

5.1wait

wait是Object的一个方法，wait是使进程变为阻塞状态。
我们通过代码来进行演示：

java">public class Demo20 {public static void main(String[] args) throws InterruptedException {Object object=new Object();System.out.println("wait之前");object.wait();System.out.println("wait之后");}
}

我们发现运行时依然有错：非法监视器状态异常，监视器就是指的sychronized。
在这里插入图片描述
wait在执行的时候只做三件事情：
1.释放锁资源
2.让线程进入阻塞状态
3.当线程被唤醒重新获取锁
对代码进行修改：

java">public class Demo20 {public static void main(String[] args) throws InterruptedException {Object object=new Object();System.out.println("wait之前");synchronized (object){object.wait();}System.out.println("wait之后");}
}

在这里插入图片描述

5.2notify

这时我们会发现wait会一直持续等待，知道有其他线程调用notify唤醒它。
notify是一次唤醒一个进程，而notifyAll是一次唤醒所有进程。

java">public class Demo16 {public static void main(String[] args) throws InterruptedException {Object object=new Object();Thread t=new Thread(()->{try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (object){System.out.println("进行通知");object.notify();}});t.start();System.out.println("wait之前");synchronized (object){object.wait();}System.out.println("wait之后");}
}

在这里插入图片描述
wait除了默认的无参版本，还有一个带参的版本，但参版本就是指定超时时间避免无休止等待。

6.总结

本篇文章主要介绍了sychronized加锁操作，死锁的成因，死锁的解决，内存可见性问题以及内存可见的解决方案，最后介绍了wait和notify的运用。

下期预告：多线程代码案例


http://www.ppmy.cn/devtools/34441.html

相关文章

2万字长文：海豚调度器（DolphinScheduler）面试题深入了解

2万字长文：海豚调度器（DolphinScheduler）面试题深入了解

目录 海豚调度器的主要功能和特点 海豚调度器与Oozie、Azkaban等调度器相比的优势
阅读更多...
​可视化大屏C位图：3D模型，可视化大屏的画龙点睛之处

​可视化大屏C位图：3D模型，可视化大屏的画龙点睛之处

Hello&#xff0c;我是大千UI工场&#xff0c;本期可视化大屏的焦点图&#xff08;C位&#xff09;分享将图表作为焦点图的情形&#xff0c;欢迎友友们关注、评论&#xff0c;如果有订单可私信。 3D模型在可视化大屏中有很大的价值&#xff0c;以下是一些相关的优点&#xff1a…
阅读更多...
计算机服务器中了halo勒索病毒怎么处理，halo勒索病毒解密流程步骤

计算机服务器中了halo勒索病毒怎么处理，halo勒索病毒解密流程步骤

在网络技术飞速发展的时代&#xff0c;越来越多的企业走向了数字化办公模式&#xff0c;利用网络可以开展各项工作业务&#xff0c;网络也为企业的生产运营提供了极大便利&#xff0c;但网络是一把双刃剑&#xff0c;从网络出现就一直存在网络数据安全问题&#xff0c;这也是众…
阅读更多...
Rust语言入门：系统编程的未来

Rust语言入门：系统编程的未来

Rust 是一种系统编程语言&#xff0c;自 2010 年首次发布以来&#xff0c;它因其独特的内存安全保证和现代语言特性而备受关注。Rust 被设计用来创建高性能且安全的应用程序&#xff0c;特别是在操作系统、文件系统、游戏引擎和网络服务等领域。以下是关于 Rust 语言的基本介绍…
阅读更多...
删掉的文件在哪里找到并恢复？3个恢复策略公开！

删掉的文件在哪里找到并恢复？3个恢复策略公开！

“我一不小心就删除了一个比较重要的文件&#xff0c;不知道我可以在哪里找到这个删除的文件并将它恢复呢&#xff1f;” 在数字时代&#xff0c;电脑已成为我们生活和工作中不可或缺的工具。然而&#xff0c;随着我们使用电脑进行各种操作&#xff0c;有时不可避免地会出现误删…
阅读更多...
【C++】学习笔记——vector_3

【C++】学习笔记——vector_3

文章目录 七、vector3. vector的模拟实现4. vector实现代码整合 未完待续 七、vector 3. vector的模拟实现 上篇文章我们讲解了非常 玄幻 的拷贝构造函数&#xff0c;同样的方法&#xff0c;我们也能用这种方法来实现 赋值重载函数 。 void swap(vector<T>& v) {s…
阅读更多...
变老相机app

变老相机app

变老相机app 在手机上使用“变老相机”app&#xff0c;其中的时光穿梭功能可以生成10岁、20岁、50岁、70岁的照片 目的 得到未来自己的照片&#xff0c;能够更有效地督促我们为老年的自己存款。
阅读更多...
Web安全：SQL注入漏洞详解，SQL注入常见功能、危害、分类、判断注入点、注入方式

Web安全：SQL注入漏洞详解，SQL注入常见功能、危害、分类、判断注入点、注入方式

「作者简介」&#xff1a;2022年北京冬奥会网络安全中国代表队&#xff0c;CSDN Top100&#xff0c;就职奇安信多年&#xff0c;以实战工作为基础对安全知识体系进行总结与归纳&#xff0c;著作适用于快速入门的 《网络安全自学教程》&#xff0c;内容涵盖系统安全、信息收集等…
阅读更多...
最新文章

Copyright @ 2022~2023