概念

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

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

  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. leetcode 每日签到 409. 最长回文串

    题目: 最长回文串 给定一个包含大写字母和小写字母的字符串,找到通过这些字母构造成的最长的回文串. 在构造过程中,请注意区分大小写.比如 "Aa" 不能当做一个回文字符串. 注意: ...

  2. Tensorflow实现MNIST手写数字识别

    之前我们讲了神经网络的起源.单层神经网络.多层神经网络的搭建过程.搭建时要注意到的具体问题.以及解决这些问题的具体方法.本文将通过一个经典的案例:MNIST手写数字识别,以代码的形式来为大家梳理一遍神 ...

  3. nodejs 模块加载顺序

    nodejs 模块加载顺序 一.当引入模块的形式是 require('lt') 时(1).先找当前文件夹下的node_modules文件夹下的lt文件夹下的package.json 文件指定的main ...

  4. 双剑合璧的开源项目Kitty-Cloud

    项目地址 https://github.com/yinjihuan/kitty-cloud 背景 做这个项目主要是想将个人的一些经验通过开源的形式进行输出,不一定能帮到所有人,有感兴趣的朋友可以关注学 ...

  5. zookeeper 负载均衡

    1,原理 将启动的服务注册到zookeeper 注册中心上面,采用临时节点,zookeeper 客户端从注册中心上读取服务的信息,之后再本地采用负载均衡算法(取模算法),将请求轮询到每个服务. 同时z ...

  6. 意外发现PHP另一个显示转换类型 binary

    竟然不知道除了(string)$a之外,还有(binary)$a知道unset可以不加括号,但不知道还有这种写法(unset) 请看lex文件(php-7.1.8) <ST_IN_SCRIPTI ...

  7. 如何有效的阅读JDK源码

    阅读Java源码的前提条件: 1.技术基础 在阅读源码之前,我们要有一定程度的技术基础的支持. 假如你从来都没有学过Java,也没有其它编程语言的基础,上来就啃<Core Java>,那样 ...

  8. js内置对象常用方法

    JS内置对象: ● String对象:处理所有的字符串操作 ● Math对象:处理所有的数学运算 ● Date对象:处理日期和时间的存储.转化和表达 ● Array对象:提供一个数组的模型.存储大量有 ...

  9. 【学习笔记】CART算法

    1. 背景介绍 CART(Classification and Regression Trees,分类回归树)算法是一种树构建算法,既可以用于分类,也可以用于回归.它的工作原理是:使用二元切分来处理连 ...

  10. Ruby学习计划-(1)搭建开发环境

    环境搭建        工欲善其事,必先利其器.要学习一门新的语言当然也需要搭建好开发环境,这样才能更加高效的完成工作提高自身的工作效率.PS:由于自己使用的是MacBookPro,因此之后的所有问题 ...