概念

  在了解线程安全问题之前,必须先知道为什么需要并发,并发给我们带来什么问题。

为什么需要并发,多线程?

  1. 时代的召唤,为了更充分的利用多核CPU的计算能力,多个线程程序可通过提高处理器的资源利用率来提升程序性能。
  2. 方便业务拆分,异步处理业务,提高应用性能。

   多线程并发产生的问题?

  1. 大量的线程让CPU频繁上下文切换带来的系统开销。
  2. 临界资源线程安全问题(共享,可变)。
  3. 容易造成死锁。

注意:当多个线程执行一个方法时,该方法内部的局部变量并不是临界资源,因为这些局部变量是在每个线程的私有栈中,因此不具有共享性质,不会导致线程安全问题。

可见性

多线程访问同一个变量时,如果有一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。这是因为为了保证多个CPU之间的高速缓存是一致的,操作系统会有一个缓存一致性协议,volatile就是通过OS的缓存一致性协议策略来保证了共享变量在多个线程之间的可见性。

  1. public class ThreadDemo2 {
  2.  
  3. private static boolean flag = false;
  4.  
  5. public void thread_1(){
  6. flag = true;
  7. System.out.println("线程1已对flag做出改变");
  8. }
  9.  
  10. public void thread_2(){
  11. while (!flag){
  12. }
  13. System.out.println("线程2->flag已被修改,成功打断循环");
  14. }
  15.  
  16. public static void main(String[] args) {
  17. ThreadDemo2 threadDemo2 = new ThreadDemo2();
  18. Thread thread2 = new Thread(()->{
  19. threadDemo2.thread_2();
  20. });
  21. Thread thread1= new Thread(()->{
  22. threadDemo2.thread_1();
  23. });
  24. thread2.start();
  25. try {
  26. Thread.sleep(1000);
  27. } catch (InterruptedException e) {
  28. e.printStackTrace();
  29. }
  30. thread1.start();
  31. }
  32. }

执行结果

  1. 线程1已对flag做出改变

代码无论执行多少次,线程2的输出语句都不会被打印。为flag添加volatile修饰后执行,线程2执行的语句被打印

执行结果

  1. 线程1已对flag做出改变
  2. 线程2->flag已被修改,成功打断循环

局限:volatile只是保证共享变量的可见性,无法保证其原子性。多个线程并发时,执行共享变量i的i++操作<==> i = i + 1,这是分两步执行,并不是一个原子性操作。根据缓存一致性协议,多个线程读取i并对i进行改变时,其中一个线程抢先独占i进行修改,会通知其他CPU我已经对i进行修改,把你们高速缓存的值设为无效并重新读取,在并发情况下是可能出现数据丢失的情况的。

  1. public class ThreadDemo3 {
  2. private volatile static int count = 0;
  3. public static void main(String[] args) {
  4. for (int i = 0; i < 10; ++i){
  5. Thread thread = new Thread(()->{
  6. for (int j = 0; j < 1000; ++j){
  7. count++;
  8. }
  9. });
  10. thread.start();
  11. }
  12. try {
  13. Thread.sleep(1000);
  14. } catch (InterruptedException e) {
  15. e.printStackTrace();
  16. }
  17. System.out.println("count执行的结果为->" + count);
  18. }
  19. }

执行结果

  1. count执行的结果为->9561

注意:这个结果是不固定的,有时10000,有时少于10000。

原子性

就像恋人一样同生共死,表现在多线程代码中程序一旦开始执行,就不会被其他线程干扰要嘛一起成功,要嘛一起失败,一个操作不可被中断。在上文的例子中,为什么执行结果不一定等于10000,就是因为在count++是多个操作,1.读取count值,2.对count进行加1操作,3.计算的结果再赋值给count。这几个操作无法构成原子操作的,在一个线程读取完count值时,另一个线程也读取他并给它赋值,根据缓存一致性协议通知其他线程把本次读取的值置为无效,所以本次循环操作是无效的,我们看到的值不一定等于10000,如何进行更正---->synchronized关键字

  1. public class ThreadDemo3 {
  2. private volatile static int count = 0;
  3. private static Object object = new Object();
  4. public static void main(String[] args) {
  5. for (int i = 0; i < 10; ++i){
  6. Thread thread = new Thread(()->{
  7. for (int j = 0; j < 1000; ++j){
  8. synchronized (object){
  9. count++;
  10. }
  11. }
  12. });
  13. thread.start();
  14. }
  15. try {
  16. Thread.sleep(1000);
  17. } catch (InterruptedException e) {
  18. e.printStackTrace();
  19. }
  20. System.out.println("count执行的结果为->" + count);
  21. }
  22. }

执行结果

  1. count执行的结果为->10000

加锁后,线程在争夺执行权就必须获取到锁,当前线程就不会被其他线程所干扰,保证了count++的原子性,至于synchronized为什么能保证原子性,篇幅有限,下一篇在介绍。

有序性

jmm内存模型允许编译器和CPU在单线程执行结果不变的情况下,会对代码进行指令重排(遵守规则的前提下)。但在多线程的情况下却会影响到并发执行的正确性。

  1. public class ThreadDemo4 {
  2. private static int x = 0,y = 0;
  3. private static int a = 0,b = 0;
  4. private static int i = 0;
  5. public static void main(String[] args) throws InterruptedException {
  6. for (;;){
  7. i++;
  8. x = 0;y = 0;
  9. a = 0;b = 0;
  10. Thread thread1 = new Thread(new Runnable() {
  11. @Override
  12. public void run() {
  13. waitTime(10000);
  14. a = 1;
  15. x = b;
  16. }
  17. });
  18. Thread thread2 = new Thread(new Runnable() {
  19. @Override
  20. public void run() {
  21. b = 1;
  22. y = a;
  23. }
  24. });
  25. thread1.start();
  26. thread2.start();
  27. thread1.join();
  28. thread2.join();
  29. System.out.println("第" + i + "次执行结果(" + x + "," + y + ")");
  30. if (x == 0 && y == 0){
  31. System.out.println("在第" + i + "次发生指令重排,(" + x + "," + y + ")");
  32. break;
  33. }
  34. }
  35. }
  36. public static void waitTime(int time){
  37. long start = System.nanoTime();
  38. long end;
  39. do {
  40. end = System.nanoTime();
  41. }while (start + time >= end);
  42. }
  43.  
  44. }

执行结果

  1. 1次执行结果(0,1)
  2. 2次执行结果(1,0)
  3. ....
  4. 35012次执行结果(0,1)
  5. 35013次执行结果(0,0)
  6. 在第35013次发生指令重排,(0,0)

如何解决上诉问题哪?volatile的另一个作用就是禁止指令重排优化,它的底层是内存屏障,其实就是一个CPU指令,一个标识,告诉CPU和编译器,禁止在这个标识前后的指令执行重排序优化。内存屏障的作用有两个,一个就是上文所讲的保证变量的内存可见性,第二个保证特定操作的执行顺序。

补充

指令重排序:Java语言规范规定JVM线程内部维持顺序化语义,程序的最终结果与它顺序化情况的结果相等,那么指令的执行顺序可以和代码顺序不一致。JVM根据处理器特性,适当的堆机器指令进行重排序,使机器指令更符号CPU的执行特性,最大限度发挥机器性能。

as-if-serial语义:不管怎么重排序,单线程程序的执行结果不能被改变,编译器和处理器都必须遵守这个原则。

happens-before原则:辅助保证程序执行的原子性,可见性和有序性的问题,判断数据是否存在竞争,线程是否安全的依据(JDK5)

1. 程序顺序原则,即在一个线程内必须保证语义串行性,也就是说按照代码顺序执行。

2. 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前,也就是说, 如果对于一个锁解锁后,再加锁,那么加锁的动作必须在解锁动作之后(同一个锁)。

3. volatile规则 volatile变量的写,先发生于读,这保证了volatile变量的可见性,简单 的理解就是,volatile变量在每次被线程访问时,都强迫从主内存中读该变量的值,而当 该变量发生变化时,又会强迫将最新的值刷新到主内存,任何时刻,不同的线程总是能 够看到该变量的最新值。

4. 线程启动规则 线程的start()方法先于它的每一个动作,即如果线程A在执行线程B的 start方法之前修改了共享变量的值,那么当线程B执行start方法时,线程A对共享变量 的修改对线程B可见

5. 传递性 A先于B ,B先于C 那么A必然先于C

6. 线程终止规则 线程的所有操作先于线程的终结,Thread.join()方法的作用是等待当前 执行的线程终止。假设在线程B终止之前,修改了共享变量,线程A从线程B的join方法 成功返回后,线程B对共享变量的修改将对线程A可见。

7. 线程中断规则 对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到中 断事件的发生,可以通过Thread.interrupted()方法检测线程是否中断。

java多线程3:原子性,可见性,有序性的更多相关文章

  1. Java高并发--原子性可见性有序性

    Java高并发--原子性可见性有序性 主要是学习慕课网实战视频<Java并发编程入门与高并发面试>的笔记 原子性:指一个操作不可中断,一个线程一旦开始,直到执行完成都不会被其他线程干扰.换 ...

  2. Java内存模型JMM 高并发原子性可见性有序性简介 多线程中篇(十)

    JVM运行时内存结构回顾 在JVM相关的介绍中,有说到JAVA运行时的内存结构,简单回顾下 整体结构如下图所示,大致分为五大块 而对于方法区中的数据,是属于所有线程共享的数据结构 而对于虚拟机栈中数据 ...

  3. Java多线程之内存可见性和原子性:Synchronized和Volatile的比较

    Java多线程之内存可见性和原子性:Synchronized和Volatile的比较     [尊重原创,转载请注明出处]http://blog.csdn.net/guyuealian/article ...

  4. 细说Java多线程之内存可见性

    编程这些实践的知识技能,每一次学习使用可能都会有新的认识 一.细说Java多线程之内存可见性(数据挣用)         1.共享变量在线程间的可见性                共享变量:如果一个 ...

  5. jvm高级特性(5)(1)(原子性,可见性,有序性,volatile,概述)

    JVM高级特性与实践(十二):高效并发时的内外存交互.三大特征(原子.可见.有序性) 与 volatile型变量特殊规则 简介: 阿姆达尔定律(Amdahl):该定律通过系统中并行化与串行化的比重来描 ...

  6. Java核心复习—— 原子性、有序性与Happens-Before

    一. 产生并发Bug的源头 可见性 缓存导致的可见性问题 原子性 线程切换带来的原子性问题 有序性 编译优化带来的有序性问题 上面讲到了 volatile 与可见性,本章再主要讲下原子性.有序性与Ha ...

  7. 细说Java多线程之内存可见性笔记

    个人博客网:https://wushaopei.github.io/    (你想要这里多有) 说明:多线程的内存可见性涉及到多线程间的数据争用,也涉及到了多线程间的数据可见性 一.共享变量在线程间的 ...

  8. java 原子性 可见性 有序性

    原子性 原子性是指一个操作或多个操作要么全部执行完成且执行过程不被中断,要么就不执行. 如向变量x赋值操作 x = 10 是原子性的,就不会出现赋值操作进行到一半(x的低16位赋值成功,高16位没有赋 ...

  9. java多线程之内存可见性-synchronized、volatile

    1.JMM:Java Memory Model(Java内存模型) 关于synchronized的两条规定: 1.线程解锁前,必须把共享变量的最新值刷新到主内存中 2.线程加锁时,将清空工作内存中共享 ...

  10. Java多线程之内存可见性

    阅读本文约“3分钟” 共享变量在线程间的可见性 synchronized实现可见性 volatile实现可见性 —指令重排序 —as-if-serial语义 —volatile使用注意事项 synch ...

随机推荐

  1. 干货|漫画算法:LRU从实现到应用层层剖析(第一讲)

    今天为大家分享很出名的LRU算法,第一讲共包括4节. LRU概述 LRU使用 LRU实现 Redis近LRU概述 第一部分:LRU概述 LRU是Least Recently Used的缩写,译为最近最 ...

  2. PySpark初级教程——第一步大数据分析(附代码实现)

    概述 数据正以前所未有的速度与日俱增 如何存储.处理和使用这些数据来进行机器学习?spark正可以应对这些问题 了解Spark是什么,它是如何工作的,以及涉及的不同组件是什么 简介 我们正在以前所未有 ...

  3. CVPR 2019细粒度图像分类竞赛中国团队DeepBlueAI获冠军 | 技术干货分享

    [导读]CVPR 2019细粒度图像分类workshop的挑战赛公布了最终结果:中国团队DeepBlueAI获得冠军.本文带来冠军团队解决方案的技术分享. 近日,在Kaggle上举办的CVPR 201 ...

  4. 给 EF Core 查询增加 With NoLock

    给 EF Core 查询增加 With NoLock Intro EF Core 在 3.x 版本中增加了 Interceptor,使得我们可以在发生低级别数据库操作时作为 EF Core 正常运行的 ...

  5. inux上安装mysql

    目录 1.先验证是否安装了mysql 2.先下载mysql的repo源 3.安装mysql rpm包,执行命令: 4.安装mysql,执行命令: 5.登录然后重置密码,执行: 6.执行命令赋权,重启m ...

  6. coding++:idea提交SVN或GIT时,忽略某些文件

    设置步骤:Settings→Editor→File Types在窗口最下方“Ignore files and folders”一栏中添加如下忽略: *.iml;*.idea;*.gitignore;* ...

  7. [vijos1048]送给圣诞夜的贺卡<DFS剪枝>

    题目链接:https://www.vijos.org/p/1048 很多人一看就想出了思路,不就是一个裸的dfs蛮...但是..在n<=50的情况下,朴素会直接tle..... 然后我就开始剪枝 ...

  8. layuiadmin使用Ueditor 获取不了数据的解决方法

    表单根元素请使用form元素,layuiadmin 默认使用div作为表单根元素. <form class="layui-form"> <textarea nam ...

  9. 手工注入——MySQL手工注入实战和分析

    今天进行了MySQL手工注入实战,分享一下自己的实战过程和总结,这里环境使用的是墨者学院的在线靶场.话不多说,咱们直接开始. 第一步,判断注入点 通过 ' 和构造 and 1=1 和 and 1=2 ...

  10. linux 之虚拟机的安装与介绍

    linux 零基础入门1.1linux介绍 操作系统用途: 管理硬件 驱动硬件 管理软件 分配资源1.2 linux的发展unix -> windows ->linuxlinux 免费 开 ...