Java多线程-----线程安全问题（详解）

news2024/9/19 7:26:09

目录

🍇一.线程安全问题的引入：

🍒二.线程安全问题产生的原因：

🍌三.如何解决线程安全问题：

🎉1.synchronized关键字:

🦉sychronized关键字的特性:

✨2.volatile关键字:

🍇一.线程安全问题的引入：

首先我们来看下面一段代码，我们通过两个线程同时操作一个静态成员变量count，使其一共累加10w次，看看结果：

public class Main {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        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,t2线程结束，统计此时count的累加结果
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

第一次执行结果：
59355
第二次执行结果：
54362
第三次执行结果：
53976

这是我们发现，三次累加count的结果都不一样，很明显，这里出现了bug!

因为多个线程并发执行，引起的bug,这样的bug称为“线程安全问题”或者叫做“线程不安全”

🍒二.线程安全问题产生的原因：

那么这个问题是怎样产生的呢？这里，我们引出线程安全问题产生的原因：

  • 线程在操作系统中是随机调度，抢占式执行的【根本原因】

程序中的多个线程是并发执行的，某个线程若想被执行必须要得到CPU的使用权，Java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称为线程的调度。

两种线程调度的模式：

①.分时调度模式：让所有的线程轮流获得CPU的使用权，并且平均分配给每个线程占用CPU的时间段

②.抢占式调度模式：让就绪队列中优先级高的线程优先占用CPU，而对于优先级相同的线程，随机选择一个线程使其占用CPU，当它失去了CPU的使用权后，在随机选择其他线程使其占用CPU。

  • 多个线程，由于是并发执行的，此时如果同时修改一个共享数据的代码块或则变量，会导致线程安全问题

  • 修改操作，不是“原子”的

这里的原子性与MySQL事务中的原子性是一个意思，对于一组操作，这组操作是不可分割的最小单元，程序运行时要么同时成功，要么同时失败，不存在程序运行一般就结束的情况，这个操作要求一气呵成。而在CPU的视角，一条指令就是CPU上不可分割的最小单元，CPU在进行调度切换线程的时候，势必会确保执行完一条完整的指令，这个过程包含取指令，解析指令和执行指令。而上述的count++这个操作，就不是原子的，其在CPU看来有三个指令：

①.把内存中的数据，读取到CPU寄存器中 (load操作)

②.把CPU寄存器里的值+1 （add操作）

③.把寄存器里的值，写回到内存中 （save操作）

此时我们在对上述操作进行分析t1,t2两个线程：

  • 内存可见性问题：

可见性定义：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

在多线程环境下，一个线程对共享变量的操作对其他线程是不可见的。Java提供了volatile关键字来保证可见性，当一个变量被volatile修饰后，表示着本地内存无效，当一个线程修改共享变量后他会立即被更新到主存中，其他线程读取共享变量的时候，会直接从主存中读取，从而实现了可见性.

  • 指令重排序:

在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。重排序分为如下三种：

1属于编译器重排序，2和3属于处理器重排序。这些重排序可能会导致多线程程序出现内存可见性问题。

JVM翻译字节码指令，CPU执行机器码指令，都可能发生重排序来优化执行效率

比如有这样三步操作：(1) 去前台取U盘 (2) 去教室写作业 (3) 去前台取快递 JVM会对指令优化，也就是重排序，新的顺序为(1)(3)(2),这样来提高效率

导致线程安全问题的小结：

  1. 线程是抢占式的执行，线程间的调度充满了随机性
  2. 多个线程对同一个变量进行修改操作
  3. 对变量的操作不是原子性的
  4. 内存可见性导致的线程安全
  5. 指令重排序也会影响线程安全

🍌三.如何解决线程安全问题：

🎉1.synchronized关键字:

解决方案：将操作共享数据的代码块锁起来

①.修饰代码块：

synchronized(锁对象)
{
  //操作共享数据的代码
 }；

特点1：锁默认打开，有一个线程进去了，锁自动关闭

特点2：里面的代码全部执行完毕，线程出来，锁自动打开

特点3:锁对象，一定是唯一的

②.修饰普通方法：

public synchronized void doSomething(){
  //操作共享数据的代码
}

其等同于：

public void doSomething(){
  //this->当前对象的引用
  synchronized(this){
    //操作共享数据的代码块
  }
}

③.修饰静态方法：

public static synchronized void doSomething(){
  //操作共享数据的代码块
}

其相当于

public static void doSomething(){
  //锁对象是当前类的字节码文件对象
  synchronized(A.class){
    //操作共享数据的代码块
  }
}

这里我们利用synchronized关键字，解决上述线程安全问题：通过两个线程同时操作一个静态成员变量count，使其一共累加10w次

public class Main {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for(int i = 0;i < 50000;i++){
                //利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作
                //从而解决了线程安全问题
                synchronized (Main.class){
                    count++;
                }
            }
        });

        Thread t2 = new Thread(()->{
           for(int i = 0;i < 50000;i++){
               //利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作
               synchronized(Main.class){
                   count++;
               }
           }
        });

        t1.start();
        t2.start();
        //让主线程等待t1,t2线程结束，统计此时count的累加结果
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果（此时我们无论运行多少次，count的计算结果都是10w）：

sychronized关键字的作用：

①.sychronized是基于对象头加锁的，特别注意：不是对代码加锁，所说的加锁操作就是给这个对象的对象头里设置了一个标志位，一个对象在同一时间只能有一个线程获取到该对象的锁

②.sychronized保证了原子性，可见性，有序性（这里的有序不是指指令重排序，而是具有相同锁的代码块按照获取锁的顺序执行）

🦉sychronized关键字的特性:

1).互斥：

synchronized 会起到互斥效果,某个线程执⾏到某个对象的synchronized中时,其他线程如果也执⾏ 到同⼀个对象synchronized就会阻塞等待.

• 进⼊synchronized修饰的代码块,相当于加锁

• 退出synchronized修饰的代码块,相当于解锁

加锁的大致过程：

2) 可重⼊：

synchronized 同步块对同⼀条线程来说是可重⼊的，不会出现⾃⼰把⾃⼰锁死的问题。

⼀个线程没有释放锁,然后⼜尝试再次加锁，按照之前对于锁的设定,第⼆次加锁的时候,就会阻塞等待.直到第⼀次的锁被释放,才能获取到第二个锁.但是释放第⼀个锁也是由该线程来完成,结果这个线程已经躺平了,啥都不想⼲了,也就⽆法进行解锁操作.这时候就会死锁.

Java 中的synchronized是可重⼊锁,因此没有上⾯的问题

public class Main2 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for(int i = 0;i < 50000;i++){
                //利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作
                //从而解决了线程安全问题
                synchronized (Main2.class){
                    synchronized (Main2.class){
                        count++;
                    }
                }
            }
        });

        Thread t2 = new Thread(()->{
           for(int i = 0;i < 50000;i++){
               //利用锁将操作共享数据的代码块锁起来，每次只允许一个线程进入进行操作
               synchronized (Main2.class){
                   synchronized (Main2.class){
                       count++;
                   }
               }
           }
        });

        t1.start();
        t2.start();
        //让主线程等待t1,t2线程结束，统计此时count的累加结果
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果：

在可重⼊锁的内部,包含了"线程持有者"和"计数器"两个信息.

• 如果某个线程加锁的时候,发现锁已经被⼈占⽤,但是恰好占⽤的正是⾃⼰,那么仍然可以继续获取到锁,并让计数器⾃增.

• 解锁的时候计数器递减为0的时候,才真正释放锁.(才能被别的线程获取到)

✨2.volatile关键字:

volatile关键字的作用主要有如下两个：(volatile是用来修饰变量的，它的作用是保证可见性，有序性)

  1. 保证内存可见性：基于屏障指令实现，即当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

  2. 保证有序性：禁止指令重排序。编译时 JVM 编译器遵循内存屏障的约束，运行时靠屏障指令组织指令顺序。

注意：volatile 不能保证原子性

public class Main {
    public boolean flag = true;
    //改变flag的值
    public void changeFlag(){
        this.flag = false;
    }
    public static void main(String[] args) {
        Main test = new Main();
        Thread t1 = new Thread(()->{
            while(test.flag){

            }
            System.out.println("线程一结束~~~");
        });

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(1000);
                test.changeFlag();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程二结束");
        });

        t1.start();
        t2.start();
    }
}

运行结果：

当我们给变量flag加上volatile关键字:

 public volatile boolean flag = true;

运行结果（从打印结果不难看出，线程一读取到了flag修改后的值，线程一顺利结束）：

说到可见性，我们需要先了解一下Java内存模型，Java内存模型如下所示：

线程之间的共享变量存储在主内存中（Main Memory）中，每个线程都一个都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。

所以当一个线程把主内存中的共享变量读取到自己的本地内存中，然后做了更新。在还没有把共享变量刷新的主内存的时候，另外一个线程是看不到的。 引入volatile关键字，保证了内存的可见性。

由于volatile不能保证原子性，对于count++这类非原子指令的操作来说，其并不能保证线程安全：

public class Main {
    public static volatile int count = 0;
    public static void main(String[] args) throws InterruptedException {
        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,t2线程结束，统计此时count的累加结果
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果：

//第一次运行结果：
77463
//第二次运行结果：
76841
//第三次运行结果：
 79114

Volatile和Synchronized的比较：

①.volatile是轻量级的synchronized,因为它不会引起上下文的切换和调度，所以volatile性能更好

②.volatile只能修饰变量，synchronized可以修饰方法，静态方法，代码块

③.volatile对任意单个变量的读/写具有原子性，但是类似于count++这种复合操作不具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码执行具有原子性

④.多线程访问volatile不会发生阻塞，而synchronized会发生阻塞

⑤.volatile使变量在多线程之间的可见，synchronized保证多线程之间共享资源访问的同步性

参考资料：

Volatile关键字的作用-CSDN博客

线程安全问题（面试常考）-CSDN博客

结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1937308.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

03 Git的基本使用

03 Git的基本使用

第3章&#xff1a;Git的基本使用 一、创建版本仓库 一&#xff09;TortoiseGit ​ 选择项目地址&#xff0c;右键&#xff0c;创建版本库 ​ 初始化git init版本库 ​ 查看是否生成.git文件&#xff08;隐藏文件&#xff09; 二&#xff09;Git ​ 选择项目地址&#xff0c…
阅读更多...
数据隔离级别查询一致导致重复退款

数据隔离级别查询一致导致重复退款

Transactionalpublic void updateAfsState() {String no "500001880002";OrderReturn orderReturnDb orderReturnModel.getOrderReturnByAfsSn(no);log.info("1.该售后单状态&#xff1a;{}" , orderReturnDb.getState());if(orderReturnDb.getState().e…
阅读更多...
【人工智能】机器学习 -- 贝叶斯分类器

【人工智能】机器学习 -- 贝叶斯分类器

目录 一、使用Python开发工具&#xff0c;运行对iris数据进行分类的例子程序NaiveBayes.py&#xff0c;熟悉sklearn机器实习开源库。 1. NaiveBayes.py 2. 运行结果 二、登录https://archive-beta.ics.uci.edu/ 三、使用sklearn机器学习开源库&#xff0c;使用贝叶斯分类器…
阅读更多...
vue使用了代理跨域，部署上线，使用Nginx配置出现问题，访问不到后端接口

vue使用了代理跨域，部署上线，使用Nginx配置出现问题，访问不到后端接口

1、如果路由的mode是history模式的要加上框框里的哪句&#xff0c;然后配置下面的location router location / {root /usr/local/app/dist/; #vue文件dist的完整路径try_files $uri $uri/ router;index index.html index.htm;}#error_page 500 502 503 504 /50x.html;lo…
阅读更多...
缓存弊处的体验：异常

缓存弊处的体验：异常

缓存&#xff08;cache&#xff09;&#xff0c;它是什么东西&#xff0c;有神马用&#xff0c;在学习内存的时候理解它作为一个存储器&#xff0c;来对接cpu和内存&#xff0c;来调节cpu与内存的速度不匹配的问题。 缓存&#xff0c;一个偶尔可以听到的专业名词&#xff0c;全…
阅读更多...
深入理解FFmpeg--软/硬件解码流程

深入理解FFmpeg--软/硬件解码流程

FFmpeg是一款强大的多媒体处理工具&#xff0c;支持软件和硬件解码。软件解码利用CPU执行解码过程&#xff0c;适用于各种平台&#xff0c;但可能对性能要求较高。硬件解码则利用GPU或其他专用硬件加速解码&#xff0c;能显著降低CPU负载&#xff0c;提升解码效率和能效。FFmpe…
阅读更多...
Leetcode双指针法应用

Leetcode双指针法应用

1.双指针法 文章目录 1.双指针法1.1什么是双指针法&#xff1f;1.2解题思路1.3扩展 1.1什么是双指针法&#xff1f; 双指针算法是一种在数组或序列上操作的技巧&#xff0c;实际上是对暴力枚举算法的一种优化&#xff0c;通常涉及到两个索引&#xff08;或指针&#xff09;从两…
阅读更多...
ubuntu 安装图形化界面

ubuntu 安装图形化界面

前言&#xff1a; 如果在首次安装操作系统的时候是最小化安装&#xff0c;可以参照本文进行安装 安装图形化界面软件包 下载源最好提前换成国内源 sudo apt-get install ubuntu-desktop设置图形化启动 sudo systemctl set-default graphical.target重启系统 reboot验证&…
阅读更多...
《Techporters架构搭建》-Day02 集成Mybatis-plus

《Techporters架构搭建》-Day02 集成Mybatis-plus

集成Mybatis-plus Mybatis-plus集成Mybatis-plus步骤小结 Mybatis-plus Mybatis-plus官网 MyBatisPlus&#xff08;简称MP&#xff09;是一个MyBatis的增强工具&#xff0c;在MyBatis的基础上只做增强不做改变&#xff0c;为简化开发、提高效率而生。它引入了一些新的特性&…
阅读更多...
免费的数字孪生平台助力产业创新，让新质生产力概念有据可依

免费的数字孪生平台助力产业创新，让新质生产力概念有据可依

关于新质生产力的概念&#xff0c;在如今传统企业现代化发展中被反复提及。 那到底什么是新质生产力&#xff1f;它与哪些行业存在联系&#xff0c;我们又该使用什么工具来加快新质生产力的发展呢&#xff1f;今天我将介绍一款为发展新质生产力而量身定做的数字孪生工具。 新…
阅读更多...
java学校--Object类方法--toString

java学校--Object类方法--toString

第一点解析&#xff1a; 全类名就是包名加类名 getClass&#xff08;&#xff09;.getName()是得到其包名和类名如图&#xff0c;包名是com.hspedu.object_类名是Monster。 Integer.toHexString&#xff08;hashCode&#xff08;&#xff09;&#xff09;&#xff1b;是得到其…
阅读更多...
【2024最新版】Vue前端面试篇，看这一篇就够了

【2024最新版】Vue前端面试篇，看这一篇就够了

文章目录 Vue常用的指令都有哪些v-bind和v-model的区别Vue2的生命周期有哪些Vue3的生命周期有哪些vue3中创建响应式变量的方法ref和reactive原理vuex有哪些方法vue-router生命周期钩子vue框架和原生JavaScript有什么区别对于提升项目加载速度和运行效率是怎么做的webpack能做什…
阅读更多...
栈及栈的应用（有效的括号 力扣20）

栈及栈的应用（有效的括号 力扣20）

栈的概念 栈是一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶&#xff0c;另一端称为栈底。栈中的数据元素遵守后进先出LIFO&#xff08;Last In First Out&#xff09;的原则。 画个图理解一下 咱们可以观…
阅读更多...
【笔记：3D航路规划算法】一、随机搜索锚点（python实现，讲解思路）

【笔记：3D航路规划算法】一、随机搜索锚点（python实现，讲解思路）

目录 关键概念3D路径规划算法1. A*算法2. 快速随机锚点1. 初始化&#xff1a;2. 实例化搜索算法&#xff1a;3. 路径生成&#xff1a;4. 绘制图像&#xff1a; 3D路径规划是在三维空间中寻找从起点到终点的最短或最优路径的一种技术。它广泛应用于无人机导航、机器人运动规划、…
阅读更多...
关于垂直领域大模型的探索和尝试

关于垂直领域大模型的探索和尝试

节前&#xff0c;我们组织了一场算法岗技术&面试讨论会&#xff0c;邀请了一些互联网大厂朋友、今年参加社招和校招面试的同学。 针对大模型技术趋势、算法项目落地经验分享、新手如何入门算法岗、该如何准备面试攻略、面试常考点等热门话题进行了深入的讨论。 总结链接如…
阅读更多...
SpringCloud—08—高级之SpringCloud Alibaba中—Sentinel

SpringCloud—08—高级之SpringCloud Alibaba中—Sentinel

文章目录 提前预知18、Sentinel是什么&#xff1f;18.1、sentinel是什么&#xff1f;18.2、Sentinel下载安装运行18.3、Sentinel初始化监控18.4、Sentinel流控规则1、流控规则基本介绍2、流控规则之-QPS-直接-快速失败3、流控规则之-线程数-直接失败4、流控规则之-QPS-关联-快速…
阅读更多...
实战篇(十)：使用Processing创建可爱花朵：实现随机位置、大小和颜色的花朵

实战篇(十)：使用Processing创建可爱花朵：实现随机位置、大小和颜色的花朵

使用Processing创建可爱花朵 0.效果预览1. 引言2. 设置Processing环境3. 创建花朵类4. 实现花瓣绘制5. 绘制可爱的笑脸6. 鼠标点击生成花朵7. 完整代码8. 总结与扩展0.效果预览 在本教程中，我们将使用Processing编程语言来创建一个可爱的花朵生成器。通过封装花朵为一个类，并…
阅读更多...
git教程， 命令行版

git教程， 命令行版

前言 git就是代码版本管理系统&#xff0c;很简单的作用就是每一次commit之后&#xff0c;修改文件都是跟上一次commit的仓库文件做对比&#xff0c;也可以调出历史的文件查看某次commit修改了什么东西 0环境准备&#xff1a; 安装git, 百度一下&#xff0c;然后打开cmd&…
阅读更多...
教室管理系统的开发与实现（Java+MySQL）

教室管理系统的开发与实现（Java+MySQL）

引言 教室管理系统是学校和培训机构日常运营中不可或缺的工具。本文将介绍如何使用Java、Swing GUI、MySQL和JDBC开发一个简单而有效的教室管理系统&#xff0c;并涵盖系统的登录认证、教室管理、查询、启用、暂停和排课管理功能。 技术栈介绍 Java&#xff1a;作为主要编程…
阅读更多...
[数据集][目标检测]导盲犬拐杖检测数据集VOC+YOLO格式4635张2类别

[数据集][目标检测]导盲犬拐杖检测数据集VOC+YOLO格式4635张2类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;4635 标注数量(xml文件个数)&#xff1a;4635 标注数量(txt文件个数)&#xff1a;4635 标注…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023