并发编程的三大特性——有序性（ordering）

1,程序真的是按照顺序执行的吗，看看下边的小程序再说话，哈哈

package com.yang.Threads;import java.util.concurrent.CountDownLatch;/*** @Author: Gy* @Description:* @Date * @Modified By:*/
public class TestOrdering {private static int a = 0, b = 0;private static int x = 0, y = 0;public static void main(String[] args) throws InterruptedException {for (long i = 0; i < Long.MAX_VALUE; i++) {x = 0;y = 0;a = 0;b = 0;CountDownLatch countDownLatch = new CountDownLatch(2);Thread thread1 = new Thread(() -> {a = 1;x = b;countDownLatch.countDown();});Thread thread2 = new Thread(() -> {b = 1;y = a;countDownLatch.countDown();});thread1.start();thread2.start();countDownLatch.await();if (x == 0 && y == 0){System.out.println("第"+i+"次结果为("+x+","+y+")");break;}}}
}

经过多次演示终于得到了想要的控制台结果如下：

2、为什么会出现以上结果呢？如果程序是按照顺序执行的，肯定不会出现x和y同时为0的情况，答案显然是thread1先执行了x = b,thread2先执行了y = a,只有这两个条件同时满足才会出现控制台的结果，也就是说程序中前后两个没有依赖关系的语句有一定的概率会交换顺序执行，即使概率很低，但也是确确实实存在的，不管是多线程还是单线程的程序，都存在这样的概率事件
3、为什么存在乱序呢
原因是为了提高cpu的执行效率，我们知道每条java语句最终都会被转化为汇编指令去cpu执行，比较费时的指令我们叫指令a，不费时的指令我们叫指令b,cpu在执行指令a的时候不会傻傻的等待响应，而是可以利用原本的等待指令a的时间，去执行指令b,由于指令b用时很短，所有就会出现先运行完指令b，再运行完指令a的现象，也就是乱序
4、乱序存在的条件，哪种情况下允许出现乱序呢？
上面稍微提到过，前后两条没有依赖关系的语句才允许出现乱序，因为不影响单线程的最终一致性，但是在多线程中可能是有影响的，例如上面示例代码中，thread1中两个变量的定义顺序不影响thread1的执行结果，同样thread2也是如此，因为两个变量之间没有依赖关系，自己玩自己的，互不影响。再说说有依赖关系的语句，比如int x = 0; x++;这两条语句，显然不能调用执行顺序，否则会影响单线程的最终一致性。

5、看下边的一个示例，考察了线程的可见性和有序性，猜测一下num最终的结果是什么

package com.yang.Threads;/*** @Author: Gy* @Description:* @Date* @Modified By:*/
public class TestOrdering2 implements Runnable{private static /*volatile*/ boolean ready = false;private static int num;@Overridepublic void run() {while (!ready){Thread.yield();}System.out.println("num最终的值为："+num);}public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread(new TestOrdering2());thread1.start();num = 22;ready = true;thread1.join();}
}

以上程序分析：为了保证共享变量在线程间的可见性，严谨的写法应该用volatile修饰ready变量，但是该程序没有使用volatile也可以保证可见性，原因是thread1中的yield()方法会触发缓存同步，及时获取到了主线程中设置的true,还有一个原因是MESI(Intel cpu)缓存一致性协议的主动性使得thread1能及时更新主线程中更改过的ready值。
输出的num值有可能是22，也有可能是默认值0，因为根据单线程的最终一致性，num和ready两条语句没有依赖关系，所有在执行的时候，是有一定的概率打乱顺序的，如果打乱顺序，就先执行了ready = true然后子线程发现了共享变量被修改，输出默认值0。

6.图解对象创建过程,以user.java为例

package com.yang.bootmongo.entity;import lombok.Data;@Data
public class User {private int age = 8;
//    private int id;
//    private String name;public static void main(String[] args) {User user = new User();}}

通过IDEA查看 User user = new User();的bytecode汇编指令，见下图

第一步调用new User()，首先申请内存，成员变量赋默认值,即age = 0 。（此时是对象的半初始化状态）
第二步调用构造方法，成员变量赋初始值，初始化完成。
第三步局部变量引用和初始化后的对象建立关联。

7、对象的创建过程中，如果第二步和第三步指令执行顺序发生互换，会导致this对象的逸出问题，看看以下小程序，age输入的值是什么？

package com.yang.bootmongo.entity;import java.io.IOException;public class User {private int age = 8;//构造方法中启动了一个线程读取agepublic User(){new Thread(()->System.out.println(this.age)).start();}public static void main(String[] args) throws IOException {User user = new User();//为了保证主线程执行完之前子线程先执行完，此处设置主线程阻塞住不结束System.in.read();}}

输出的值大概率是8，小概率是0，上面降到了对象创建的过程中先经过半初始化状态（开辟内存，引用即this的成员变量赋默认值）后，如果第二步和第三步调换了顺序即引用与半初始化对象先建立了关联，然后调用构造方法初始化,构造方法执行的过程中，可能还没有执行完，子线程就去读取age的值，此时的age就是半初始化时的默认值。所以，所谓的this对象的逸出，指的就是对象没有完全初始化完成，处于中间状态就被拿来使用了（比如age = 0 就好比是中间状态对象的属性）。为了避免this逸出的问题，我们一般不要在构造方法中启动线程，你可以在构造方法中创建线程，但是不要在构造方法中启动，可以单独写个启动线程的方法或者以你喜欢的方式来启动，以下程序是对上一个程序的改造

package com.yang.bootmongo.entity;import java.io.IOException;public class User {private int age = 8;static Thread t1//构造方法中启动了一个线程读取agepublic User(){t1 = new Thread(() ->System.out.println(this.age));}public static void main(String[] args) throws IOException {User user = new User();t1.start();//为了保证主线程执行完之前子线程先执行完，此处设置主线程阻塞住不结束System.in.read();}}

8.DCL（Double Check Lock）双重检查+锁（以懒汉式单例模式为例），代码及分析如下

package com.yang.Threads;/*** @Author: Gy* @Description:  DCL单例模式 懒汉式* @Date * @Modified By:*/
public class TestSingleton {private static volatile Object object;private TestSingleton(Object object){}public static Object newInstance(){if(null == object){  //**A**synchronized (TestSingleton.class){  //**B**if (null == object){ //**C**object = new Object();}}}return object;}public static void main(String[] args) {System.out.println(object);Object o1 = TestSingleton.newInstance();Object o2 = TestSingleton.newInstance();System.out.println(o1 == o2);}
}

分析：比如当前有10线程(t1,t2…t10)几乎同时来获取单例对象实例，在执行到A处时，有8个线程不满足判断条件，那么此时，只剩下两个（这里叫t1和t2）线程执行到B处，只有这两个线程参与锁的竞争，我们知道多个线程同时参与锁的竞争是一件非常消耗资源的事情，所以A处判断可以节省资源提高效率，避免了8个线程不必要的锁竞争。接着开始的思路，只有两个线程(t1和t2)参与了锁竞争，假设t1先争抢到锁资源，先执行到C处，满足条件，直到执行结束释放锁（此时已经实例化了一个object对象出来），此时等待着的t2得到锁资源开始执行，执行到C处，判断不成立，直接使用已经存在的object对象。假如没有C处的代码，t1和t2各自会创建一个对象出来，会出现不是一个对象的情况。然后使用volatile修改object引用，是为了避免对象创建过程中的指令重排序的问题，避免拿到半初始化的对象来使用。

并发编程的三大特性——有序性（ordering）相关推荐

【并发编程】并发编程的三大特性
并发编程的书籍都会讲到并发编程的三大特性,这是并发编程中所有问题的根源,我们只有深刻理解了这三大特性,才不会编写出漏洞百出的并发程序. 基本概念 1.原子性,所有操作要么全部成功,要么全部失败. 2. ...
【Java 并发编程】 03 万恶的 Bug 起源—并发编程的三大特性
今天让我们一起走进并发编程中万恶的Bug起源-并发编程中三大特性.今天学习目标如下: 并发编程的三大特性都要哪些 ? 并发编程三大特性的由来? 如何解决并发编程三大特性问题? 基本概念原子性:一组操 ...
java 原子类_小学妹教你并发编程的三大特性：原子性、可见性、有序性
在并发编程中有三个非常重要的特性:原子性.有序性,.可见性,学妹发现你对它们不是很了解,她很着急,因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助,接下来的面试中也极有可能被问到,小学妹就忍 ...
原子自增_小学妹教你并发编程的三大特性：原子性、可见性、有序性
在并发编程中有三个非常重要的特性:原子性.有序性,.可见性,学妹发现你对它们不是很了解,她很着急,因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助,接下来的面试中也极有可能被问到,小学妹就忍 ...
学妹教你并发编程的三大特性：原子性、可见性、有序性
在并发编程中有三个非常重要的特性:原子性.有序性,.可见性,学妹发现你对它们不是很了解,她很着急,因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助,接下来的面试中也极有可能被问到,小学妹就忍 ...
并发编程的三大特性——原子性，可见性，有序性
一.原子性火车售票系统例子: 当客户端A检测到还有票时,执行卖票操作,还没有执行更新票数的操作时客户端B检查了票数,发现大于0,于是又进行了一次卖票操作.这就出现了同一张票被卖了两次 ...
马士兵-郑金维—并发编程—2.并发编程的三大特性
一.原子性** 1.1 什么是并发编程的原子性 JMM(Java Memory Model).不同的硬件和不同的操作系统在内存上的操作有一定差异的.Java为了解决相同代码在不同操作系统上出现的各种问 ...
【Java】保证并发安全的三大特性
一.并发编程三大特性的定义和由来并发编程这三大特性就是为了在多个线程交替执行任务的过程中保证线程安全性. 二.为什么会出现线程不安全的现象呢? 接下来我们从这三个特性切入来介绍线程不安全的原因. 1 ...
java并发编程的三大问题
java并发编程的三大问题背景: 计算机处理速度:CPU > 内存 > IO 为了平衡三者的速度差异:CPU 增加了缓存:操作系统增加了进程.线程,以分时复用 CPU:编译程序优化指令执 ...

并发编程的三大特性——有序性（ordering）

并发编程的三大特性——有序性（ordering）相关推荐

最新文章

热门文章