Java中的线程安全问题(如果想知道Java中有关线程安全问题的基本知识,那么只看这一篇就足够了!)

        前言:多线程编程已经广泛开始使用,其可以充分利用系统资源来提升效率,但是线程安全问题也随之出现,它直接影响了程序的正确性和稳定性,需要对其进行深入的理解与解决。


✨✨✨这里是秋刀鱼不做梦的BLOG

✨✨✨想要了解更多内容可以访问我的主页秋刀鱼不做梦-CSDN博客

在正式开始讲解之前,先让我们看一下本文大致的讲解内容:

目录

1.线程不安全概念及其原因

2.原子性问题

3.可见性问题

4.指令重排序问题

5.线程不安全的解决方案

        (1)synchronized关键字

补充:synchronized关键字的可重入性:

        (2)volatile关键字


1.线程不安全概念及其原因

        在多线程编程中,线程安全是一个至关重要的概念,当多个线程同时访问和操作共享数据时,如果没有适当的同步机制,可能会导致程序出现意想不到的结果。

        下面通过一个简单的代码示例来观察线程不安全现象:

// 此处定义一个int类型的变量
private static int count = 0;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {// 对count变量进行自增5w次for (int i = 0; i < 50000; i++) {count++;}});Thread t2 = new Thread(() -> {// 对count变量进行自增5w次for (int i = 0; i < 50000; i++) {count++;}});t1.start();t2.start();// 如果没有这俩join,肯定不行的。线程还没自增完,就开始打印了。很可能打印出来的count值小于预期t1.join();t2.join();// 预期结果应该是10wSystem.out.println("count: " + count);
}

        在上述代码中,我们创建了两个线程 t1 和 t2,它们都试图对共享变量 count 进行大量的自增操作,理论上,当两个线程都完成任务后,count 的值应该达到100000。然而,实际运行结果却常常小于这个预期值(读者可以复制代码在编译器中自行尝试一下),这便是典型的线程不安全现象。

        ——那么,为何会出现这种情况呢?原因有如下两个:

  1. 线程调度的随机性:线程调度是由操作系统掌控的,它会在多个线程之间随机地切换执行权。在上述代码场景中,t1t2 线程极有可能交替执行自增操作。例如,t1 线程读取了 count 的当前值(假设为0),但在执行自增操作(count++)之前,线程调度器暂停了 t1 线程,并切换到 t2 线程。此时,t2 线程同样读取到 count 的值为0,随后执行自增操作,将 count 的值更新为1。接着,t1 线程恢复执行,可它依然使用之前读取到的0进行自增操作,最终将 count 的值更新为1,而非预期的2。

  2. 多个线程修改同一变量:当多个线程同时对同一个共享变量进行写操作,且没有任何同步保障时,数据的不一致性便极易出现,在当前例子中,t1t2 都在对 count 变量进行修改,它们的操作相互干扰,最终致使结果出现偏差。

        至此,我们通过上述的讲解,我们就大致的了解了到底什么是多线程中的线程不安全以及产生线程不安全的原因了。

2.原子性问题

        在多线程中,除了上述我们讲解的当我们有多个线程同时对同一个数据进行操作从而引起的线程安全问题外,原子性问题也是可能引起线程不安全的原因,那么什么是原子性问题呢?

原子性的概念:

        原子性,从本质上讲,是指一个操作或者一组操作作为一个不可分割的整体,其执行过程要么全部成功完成,要么全部不执行,绝不存在被其他线程中断的中间状态。在多线程环境中,倘若一个操作不具备原子性,那么就极有可能出现部分执行的状况,进而导致数据错误。

        这里我们还是使用上述的两个线程各自增加count5w次的例子来进行讲解,这里再让我们看一下上述的代码:

// 定义一个共享的int类型变量count,并初始化为0
private static int count = 0;public static void main(String[] args) throws InterruptedException {// 创建第一个线程t1,其任务是对count进行50000次自增操作Thread t1 = new Thread(() -> {for (int i = 0; i < 50000; i++) {count++;}});// 创建第二个线程t2,同样对count进行50000次自增操作Thread t2 = new Thread(() -> {for (int i = 0; i < 50000; i++) {count++;}});// 启动线程t1t1.start();// 启动线程t2t2.start();// 调用t1线程的join方法,确保t1线程执行完毕t1.join();// 调用t2线程的join方法,确保t2线程执行完毕t2.join();// 预期count的值应该是100000,但实际结果往往并非如此System.out.println("count: " + count);
}

        在上述代码中的 count++ 操作,看似简单的自增指令,实际上并非原子操作,在Java语言中,count++ 大致可分解为以下三个步骤:

  • 首先,读取 count 的当前值。

  • 接着,将读取到的值加1。

  • 最后,将计算后的新值写回 count

        假设 t1 和 t2 线程同时执行 count++ 操作,就可能出现如下情形:t1 线程读取了 count 的初始值为0,然而在执行加1操作之前,线程调度器切换到了 t2 线程。t2 线程同样读取到 count 的值为0,随后进行加1操作并将结果1写回 count,此时,count 的值变为1,接着,t1 线程恢复执行,它依旧使用之前读取到的0进行加1操作,得到结果1,并将其写回 count

        如此一来,最终 count 的值仅增加了1,而非预期的2。这便是因为 count++ 操作不具备原子性,在执行过程中被其他线程中断,从而导致了错误的结果。

        ——这就是所谓的原子性问题。

3.可见性问题

        在了解完上述的两种造成多线程中的线程安全问题的原因之后,在让我们看一下另一种造成多线程线程安全的原因——内存可见性问题

        ——那么什么是内存可见性问题(可见性问题)呢?

可见性的概念:

        可见性,简单来说,是指一个线程对共享变量值的修改,能够及时且准确地被其他线程察觉到。在多线程编程的情境下,如果一个线程修改了共享变量的值,但是其他线程无法立即获取到这个修改后的最新值,那么就会产生可见性问题。

        当然,提到内存可见性问题就不得不提及Java内存模型,那么Java内存模型和内存可见性问题又有什么联系呢?

Java内存模型与可见性问题的关系:

        Java内存模型(JMM)明确规定了Java程序中变量的访问规则。每个线程都拥有自己独立的工作内存,当线程需要读取一个共享变量时,会首先将变量从主内存拷贝到自己的工作内存,然后再从工作内存中读取数据;而当线程要修改一个共享变量时,会先在工作内存中修改其副本,之后再将修改后的值同步回主内存。

        由于每个线程的工作内存相互独立,这就可能导致一种情况:一个线程修改了共享变量的值,但这个修改尚未及时同步到主内存,或者其他线程还未从主内存更新自己工作内存中的副本,从而致使其他线程无法看到该变量的最新值。

        这样我们就大致的了解了什么是Java内存模型,以及Java内存模型与可见性问题的关系了。

        我相信读者在看到这里的时候脑子里只用一个想法,我勒个去,上边这都是什么和什么啊?根本看不懂啊!没关系,接下来让我们使用一个例子来帮助你更好的理解上述内存可见性问题。

案例代码:

static class Counter {public int flag = 0;
}public static void main(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(() -> {while (counter.flag == 0) {// 线程t1在此处循环等待,直到flag的值变为非0}System.out.println("循环结束!");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个整数:");counter.flag = scanner.nextInt();});t1.start();t2.start();
}

        在这个例子中,t1 线程在一个循环里持续检查 counter.flag 的值是否为0,如果是,则持续循环等待;t2 线程等待用户输入一个整数,并将其赋值给 counter.flag。按照预期,当用户输入非0的值时,t1 线程应当结束循环并打印 "循环结束!"。

        然而,实际情况可能是,即便 t2 线程已经修改了 counter.flag 的值,t1 线程却并未立即察觉到这个变化,依旧在循环中持续等待。这是因为 t1 线程可能始终在使用自己工作内存中的 counter.flag 副本,而没有及时从主内存更新该副本,从而引发了可见性问题。

        至此,我相信读者通过上述的案例讲解之后,就对内存可见性问题有了进一步理解了!!!

4.指令重排序问题

        讲解完上述三种产生多线程问题的原因之后,还有没有其他的可能产生多线程线程安全的原因呢?还真有,其就是指令重排序问题。

指令重排序的概念:

        指令重排序是指编译器或处理器为了优化程序的性能,在不改变单线程程序语义的前提下,对指令的执行顺序进行重新排列。在单线程环境中,指令重排序通常不会引发问题,因为程序的执行结果是确定的。然而,在多线程环境下,指令重排序可能会改变代码的执行顺序,进而导致线程安全问题。

        这里我们也是使用一个案例来帮助读者来进一步理解指令重排序问题。

// 定义两个共享变量
private static boolean initialized = false;
private static int value;public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {value = 42;initialized = true;});Thread t2 = new Thread(() -> {if (initialized) {System.out.println("value: " + value);}});t1.start();t2.start();t1.join();t2.join();
}

        在这个例子中,t1 线程首先对 value 赋值为42,随后将 initialized 设置为 truet2 线程则检查 initialized 的值,如果为 true,就打印 value 的值。由于指令重排序的存在,t1 线程中的指令可能会被重新排序。

        例如,initialized = true 可能会在 value = 42 之前执行。这样一来,当 t2 线程检查 initialized 的值为 true 时,value 的值可能还未被正确赋值,从而导致打印出错误的结果(可能是0,而不是42)。

        这样我们就了解了什么是指令重排序问题了。

5.线程不安全的解决方案

        学习完上述可能产生线程安全的原因之后,接下来就让我们学习一下如何去在多线程编程中防止程序发生线程安全问题。

        (1)synchronized关键字

在学习如何使用synchronized关键字之前,先让我们看一下synchronized关键字是什么:

synchronized 关键字具有强大的互斥特性。当一个线程进入一个对象的 synchronized 方法或代码块时,其他线程若试图进入同一个对象的 synchronized 方法或代码块,将会被阻塞等待,直到持有锁的线程释放锁为止。

这里我们使用一个例子来进行讲解:

public class Demo2 {public static int number = 0;public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread thread1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {synchronized (locker) {number++;}}});Thread thread2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {synchronized (locker) {number++;}}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println(number);}
}

代码解析:

  • 静态变量 number 用于存储共享计数。
  • 使用 Object locker 作为同步锁,确保对 number 的修改是线程安全的。
  • 创建两个线程,每个线程循环 1000 次,通过 synchronized (locker) 代码块安全地增加 number
  • 启动两个线程并等待它们结束,最后输出 number 的值。

        通过上述的案例,我相信读者就可以对synchronized关键字有一定的理解了!

        当然synchronized关键字还可以修饰方法,当修饰普通方法时,锁对象为当前对象(this);修饰静态方法时,锁对象为类对象(class),例如:

public class SynchronizedMethodDemo {private static int count = 0;// 修饰普通方法,锁对象为thispublic synchronized void increment() {count++;}// 修饰静态方法,锁对象为类对象public synchronized static void staticIncrement() {count++;}
}

        需要特别注意的是,使用 synchronized 关键字会带来一定的性能开销,因为获取和释放锁的过程需要消耗时间。因此,在实际应用中,应尽可能缩小同步代码块的范围,仅在必要之处进行同步操作,以此提高程序的性能。

补充:synchronized关键字的可重入性:

        这里我们先给出可重入性的简介:

可重入性是指当一个线程已经获得了某个对象的锁后,它可以再次获得这个锁,而不会被阻塞

例如,当一个线程调用一个 synchronized 方法时,若该方法内部又调用了另一个 synchronized 方法,此时该线程能够继续获取锁并执行内部的 synchronized 方法,而不会被自身阻塞。这是因为在可重入锁的内部机制中,包含了“线程持有者”和“计数器”两个重要信息,当某个线程加锁时,若发现锁已被自己占用,那么它仍然可以顺利获取锁,并使计数器自增。只有当计数器递减为0时,锁才会真正被释放,从而允许其他线程获取该锁。

        可重入性的特点:

  1. 锁的重复获取:同一个线程可以多次获取同一个锁,而不会导致死锁。例如,如果线程 A 已经获得了对象 O 的锁,那么它可以再次进入 O 的同步方法或同步块。

  2. 计数机制:Java 的 synchronized 内部使用了一个计数机制。当一个线程获得锁时,计数器加一;当线程释放锁时,计数器减一。当计数器为零时,锁被释放。 ​​​​​​​

        如果读者看了上述的文字解释之后还是不太理解,那么我们接下看使用一个例子来帮助你进一步理解synchronized的可重入性:

public class ReentrantExample {synchronized void methodA() {System.out.println("Method A is called");methodB(); // 可以在这里调用同一个对象的另一个同步方法}synchronized void methodB() {System.out.println("Method B is called");}public static void main(String[] args) {ReentrantExample example = new ReentrantExample();example.methodA(); // 调用 methodA}
}

        在上面的例子中,当 methodA 被调用时,线程获得了锁并执行 methodA,然后可以安全地调用 methodB,因为它已经持有了该对象的锁,这就是synchronized的可重入性。

        (2)volatile关键字

在了解完了synchronized关键字之后,让我们了解一下volatile关键字,首先先让我们了解一下什么是volatile关键字:

volatile 关键字的核心作用是保证内存可见性。它强制线程在读写共享变量时,必须直接从主内存读取或写入,而不能使用工作内存中的副本。当一个线程修改了 volatile 修饰的变量时,它会立即将修改后的值刷新到主内存,并且其他线程在读取这个变量时,会直接从主内存获取最新的值,而不是使用自己工作内存中的旧副本

这里我们使用一个例子来进行讲解:

public class VolatileDemo {private volatile boolean flag = false;public void setFlag(boolean flag) {this.flag = flag;}public boolean isFlag() {return flag;}
}

        在上述代码中,flag 变量被 volatile 修饰。当一个线程调用 setFlag 方法修改 flag 的值时,其他线程能够立即察觉到这个修改。

public class VolatileExample {public static void main(String[] args) {VolatileDemo volatileDemo = new VolatileDemo();Thread t1 = new Thread(() -> {while (!volatileDemo.isFlag()) {// 线程t1在此处循环等待,直到flag的值变为true}System.out.println("t1线程检测到flag为true,结束循环");});Thread t2 = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}volatileDemo.setFlag(true);System.out.println("t2线程将flag设置为true");});t1.start();t2.start();}
}

        在这个例子中,t1 线程在一个循环中不断检查 volatileDemo.flag 的值,如果为 false,则继续循环等待;t2 线程在睡眠1秒后将 flag 设置为 true。由于 flag 被 volatile 修饰,当 t2 线程修改 flag 的值后,t1 线程能够立即看到这个修改,从而结束循环。

        这样我们就了解了volatile关键字了。


以上就是本篇文章的全部内容了~~~

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

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

奥数与C++小学四年级(第十八题 小球重量)

参考程序代码&#xff1a; #include <iostream> #include <vector>int main() {// 小球的重量std::vector<int> weights {1, 2, 3, 4, 5};// 用来存储可能的结果int a, b, c, d, e, x;// 穷举所有可能的 a, b, c, d, e 的组合for (int i 0; i < weight…

ESP32/ESP8266开发板单向一对多ESP-NOW无线通信

ESP32/ESP8266开发板单向一对多ESP-NOW无线通信 简介读取ESP32/ESP8266接收方Receiver的MAC地址ESP32/ESP8266发送方Sender程序ESP32/ESP8266接收方Receiver程序ESP-NOW通信验证总结 简介 本实验通过ESP-NOW无线通信协议实现多个ESP32/ESP 8266开发板向ESP32开发板发送数据。例…

Unity XR Interaction Toolkit 开发教程(2):导入 SDK【3.0 以上版本】

文章目录 &#x1f4d5;课程总结&#x1f4d5;安装 Unity 编辑器与打包模块&#x1f4d5;导入 OpenXR&#x1f4d5;导入 XR Interaction Toolkit&#x1f4d5;打包发布 获取完整课程以及答疑&#xff0c;工程文件下载&#xff1a; https://www.spatialxr.tech/ 视频试看链接&a…

直流电机在液压泵领域的应用

随着工业自动化的不断发展&#xff0c;液压技术已经成为现代工程中不可或缺的一部分。液压泵作为液压系统的核心部件&#xff0c;其性能直接关系到整个系统的效率和可靠性。近年来&#xff0c;直流电机因其独特的优势而逐渐应用于液压泵领域&#xff0c;为液压系统的提升与改进…

2024-10-29 商业分析-盗取他人游戏MOD牟利-记录

摘要&#xff1a; 2024-10-29 商业分析-盗取他人游戏MOD牟利-记录 事件&#xff1a; 【实锤】《真英雄》盗用本人《风林火山》mod地图售卖牟利&#xff01;_ryan_knight_12吧_百度贴吧 真英雄&#xff1f;&#xff1f;我从未见过如此厚颜无耻之人【ryan_knight_12吧】_百度贴吧…

利用钉钉与金蝶云星空进行付款单自动化集成

钉钉数据集成到金蝶云星空&#xff1a;付款申请单下推生成付款单的技术实现 在企业日常运营中&#xff0c;数据的高效流转和准确处理是业务顺利进行的关键。本文将分享一个具体的系统对接集成案例&#xff1a;如何将钉钉平台上的付款申请单&#xff0c;通过轻易云数据集成平台…

vscode 创建 vue 项目时,配置文件为什么收缩到一起展示了?

一、前言 今天用 vue 官方脚手架创建工程&#xff0c;然后通过 vscode 打开项目发现&#xff0c;配置文件都被收缩在一起了。就像下面这样 这有点反直觉&#xff0c;他们应该是在同一层级下的&#xff0c;怎么会这样&#xff0c;有点好奇&#xff0c;但是打开资源管理查看&…

001-Kotlin界面开发之Jetpack Compose Desktop学习路径

Compose Desktop学习之路 学习过程 理解Kotlin的基本语法 Compose Desktop采用Kotlin构建&#xff0c;因此对Kotlin的基本语法有很好的理解是必不可少的。你可以从官方的Kotlin文档开始。 用一句话概括&#xff0c;Kotlin是一种现代的、静态类型的编程语言&#xff0c;它结合…

Vue 组件基础(五)

一、Vue 组件的基础概念 组件(Component)是Vue最强大的功能之一。组件可以扩展HTML元素&#xff0c;封装可重用的代码。在较高层面上&#xff0c;组件是自定义元素&#xff0c;Vue的编译器为它添加特殊功能。每个组件负责一部分特定的任务&#xff0c;比如&#xff1a;显示一个…

RabbitMQ 存储机制

一、消息存储机制 不管是持久化的消息还是非持久化的消息都可以被写入到磁盘。持久化的消息在到达队列时就被写入到磁盘&#xff0c;非持久化的消息一般只保存在内存中&#xff0c;在内存吃紧的时候会被换入到磁盘中&#xff0c;以节省内存空间。这两种类型的消息的落盘处理都…

随机性、熵与随机数生成器:解析伪随机数生成器(PRNG)和真随机数生成器(TRNG)

随机性在诸多领域中扮演着至关重要的角色,涵盖密码学、仿真和机器学习等方面。因为随机性为无偏决策、不可预测序列和安全加密提供了基础。然而生成随机数是一项复杂的任务,理解伪随机数生成(pseudo-random number generation, PRNG)与真随机数生成(true random number generat…

从零开始点亮一个LED灯 —— keil下载、新建工程、版本烧录、面包板使用、实例代码

一、keil下载 参考视频&#xff1a;Keil5安装教程视频 (全套资料51和32皆可用Keil5编译设置)_哔哩哔哩_bilibili 视频内容包括下载链接、安装教程、库导入&#xff0c;非常详细&#xff01; 二、新建工程 2.1.使用stm32CubeMX新建工程 10. 使用STM32CubeMX新建工程 — [野…

嵌入式硬件电子电路设计(三)电源电路之负电源

引言&#xff1a;在对信号线性度放大要求非常高的应用需要使用双电源运放&#xff0c;比如高精度测量仪器、仪表等;那么就需要给双电源运放提供正负电源。 目录 负电源电路原理 负电源的作用 如何产生负电源 负电源能作功吗&#xff1f; 地的理解 负电压产生电路 BUCK电…

互斥量的使用

官方的描述 互斥量主要是对于共享资源的保护 其中参数要注意 osMutexRecursive&#xff1a;//递归互斥量 互斥锁嵌套属性&#xff0c;同一个线程可以在不锁定自身的情况下多次使用互斥锁。每当拥有互斥锁的线程获得互斥锁时&#xff0c;锁计数就会增加。互斥锁也必须被释放多次…

商务英语学习柯桥学外语到泓畅-老外说“go easy on me”是什么意思?

在口语中“go easy on sb ”这个短语是很常见的 01 go easy on me 怎么理解&#xff1f; 在口语中&#xff0c;“go easy on me”是一个非常常见的表达&#xff0c;通常表示请求对方在某方面对自己宽容一些&#xff0c;不要对自己太过苛刻或严厉。 短语&#xff08;go&#xff…

vscode在cmake config中不知道怎么选一个工具包?select a kit

vscode在cmake config中不知道怎么选一个工具包&#xff0c;或者发现一直在用VS的工具包想换成自己的工具包。select a kit vscode在cmake config中不知道怎么选一个工具包&#xff0c;或者发现一直在用VS的工具包想换成自己的工具包。select a kit 1.在VSCode中 按ctrlshift…

SpringBoot【实用篇】- 热部署

文章目录 目标:1.手动启动热部署2.自动启动热部署4.禁用热部署 目标: 手动启动热部署自动启动热部署热部署范围配置关闭热部署 1.手动启动热部署 当我们没有热部署的时候&#xff0c;我们必须在代码修改完后再重启程序&#xff0c;程序才会同步你修改的信息。如果我们想快速查…

AI 原生时代,更要上云:百度智能云云原生创新实践

本文整理自百度云智峰会 2024 —— 云原生论坛的同名演讲。 我今天分享的主题&#xff0c;是谈谈在云计算和 AI 技术快速发展和深入落地的背景下&#xff0c;百度智能云在云原生的基础设施产品和技术层面做的一些创新实践。 毋庸置疑&#xff0c;过去十几年云计算和 AI 技术是…

Java项目实战II基于Java+Spring Boot+MySQL的植物健康系统(开发文档+数据库+源码)

目录 一、前言 二、技术介绍 三、系统实现 四、文档参考 五、核心代码 六、源码获取 全栈码农以及毕业设计实战开发&#xff0c;CSDN平台Java领域新星创作者&#xff0c;专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末 一、前言 基于Java、…

BGP路径属性与路由反射器

前言 IBGP水平分割规则用于防止AS内部产生环路&#xff0c;在很大程度上杜绝了IBGP路由产生环路的可能性&#xff0c;但是同时也带来了新的问题&#xff1a;BGP路由在AS内部只能传递一跳&#xff0c;如果建立IBGP对等体全互联模型又会加重设备的负担。 BGP 路径属性 AS_Path …