并发编程17
关于CPU 内存
CPU（寄存器、缓存）、内存（内存条）、I/O 设备（磁盘、键盘、鼠标）都在不断迭代，在这个快速发展的过程中，有一个核心矛盾一直存在，就是这三者的速度差异。CPU 和内存的速度差异可以形象地描述为：CPU快于内存快于 I/O 设备，程序里大部分语句都要访问内存，有些还要访问 I/O所以程序整体的性能取决于最慢的操作——读写 I/O 设备，也就是说单方面提高 CPU 性能是无效的。为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，主要体现为：
- CPU 增加了缓存，以均衡与内存的速度差异；
- 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；
- unix提出的cpu的分时复用
- 任务切换时，需要把前一个操作的指令拿到内存中，再把新的操作的指令放到cpu寄存器中，比较麻烦，从而发展出多核，实现并行执行，多核引申出很多问题
- 可见性问题
- 线程切换问题
- 编译优化问题
- 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用
可见性问题
- 单核pc，所有的线程都是在一颗 CPU 一个core上执行，CPU 缓存与内存的数据一致性容易解决。因为所有线程都是操作同一个 CPU同一个core 的缓存，一个线程对缓存的写，对另外一个线程来说一定是可见的
- 一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为可见性
- 多核时代，每个core都有自己的cache，这时 core的缓存与内存的数据一致性就没那么容易解决了，当多个线程在不同的 core 上执行时，这些线程操作的是不同的 core缓存。比如下图中，线程 A 操作的是core1 上的缓存，而线程 B 操作的是 core2上的缓存，这个时候线程 A 对变量 x 的操作如果没有及时写会主存那么对于线程 B 而言就不具备可见性了
可见性问题例子
-
https://hllvm-group.iteye.com/group/topic/34932
-
import java.util.concurrent.*; public class StopThread { private static boolean stopRequested; public static void main(String[] args) throws Exception { Thread t = new Thread(new Runnable() { public void run() { int i = 0; while (!stopRequested) i++; } }); t.start(); TimeUnit.SECONDS.sleep(1); stopRequested = true; } } -
主线程运行起来，t线程的死循环并不会终止
-
代码优化（指令重排）有三个级别 编译级别、指令级别、内存级别
-
字节码优化—反编译字节码
-
cpu指令优化—看不到，需要汇编
-
代码被提升成：
-
if (!stopRequested) { while (true) i++; }
-
-
内存优化
- 内存屏障
-
测试
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * @Author 钢牌讲师--子路 **/ @Slf4j(topic = "e") public class Test2 { public static void main(String[] args) throws InterruptedException { MyThread t = new MyThread(); t.start(); while(true){ if(t.getFlag()){ System.out.println("主线程进入循环执行~~~~~"); } } } } class MyThread extends Thread{ private boolean flag = false; @SneakyThrows public void run() { TimeUnit.SECONDS.sleep(1); flag = true; System.out.println("flag="+flag); } public boolean getFlag() throws InterruptedException { return flag; } public void setFlag(boolean flag) { this.flag = flag; } } -
flag被修改了，但是"主线程进入循环执行~~~~~"不会打印
-
在while循环里面if判断语句之前加个for循环或者sout语句，又会执行，但是不知道为什么？
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * @Author 钢牌讲师--子路 **/ @Slf4j(topic = "e") public class Test2 { public static void main(String[] args) throws InterruptedException { MyThread t = new MyThread(); t.start(); while(true){ // 1.for for(int i=0;i<2;i++){ new Object(); } // 2.sout System.out.println("xxx"); if(t.getFlag()){ System.out.println("主线程进入循环执行~~~~~"); } } } } class MyThread extends Thread{ private boolean flag = false; @SneakyThrows public void run() { TimeUnit.SECONDS.sleep(1); flag = true; System.out.println("flag="+flag); } public boolean getFlag() throws InterruptedException { return flag; } public void setFlag(boolean flag) { this.flag = flag; } }
-
-
可见性问题课程没有证明？给出的链接地址并不是证明的可见性问题!
证明指令重排
CPU调度 以及上下文切换 例子
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; /** * @Author 钢牌讲师--子路 * * x=0; y=1 * * x=1;y=0 * * x=1;y=1 * * * CPU调度 以及上下文切换 * * * * x=0；y=0 * 说明CPU进行了指令重排序 * **/ @Slf4j(topic = "e") public class Test1 { public static int a = 0 , b = 0; public static int x = 0 , y = 0; @SneakyThrows public static void main(String[] args) { //计数 看第几次出现优化 int count = 0; while (true) { count++; a = 0; b = 0; x = 0; y = 0; // t1里面执行的方法不是原子性的 Thread t1 = new Thread(new Runnable() { @Override public void run() { a = 1;//1 x = b;//2 } }); // t2里面执行的方法不是原子性的 Thread t2 = new Thread(new Runnable() { @Override public void run() { b = 1;//3 y = a;//4 } }); //都可以调度 t1.start(); t2.start(); // 无法保证t1比t2先执行完 // 只能保证在执行下面的日志打印时t1和t2都执行完了，相对于主线程而言 t1.join(); t2.join(); // 得到线程执行完毕以后 变量的结果。 log.debug("第{}次输出结果：x ={}, y ={} ",count,x,y); if(x == 0 && y == 0){ break; } } } } -
会有四种结果
- x=0,y=1 — t1先启动 — 1、2、3、4代码顺序执行
- x=1,y=0 — 3、4、1、2顺序执行
- x=1,y=1 — 1、3、4、2顺序执行
CPU进行了指令重排序例子一
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; /** * @Author 钢牌讲师--子路 * * x=0; y=1 * * x=1;y=0 * * x=1;y=1 * * * CPU调度 以及上下文切换 * * * * x=0；y=0 * 说明CPU进行了指令重排序 * **/ @Slf4j(topic = "e") public class Test1 { public static int a = 0 , b = 0; public static int x = 0 , y = 0; @SneakyThrows public static void main(String[] args) { //计数 看第几次出现优化 int count = 0; while (true) { count++; a = 0; b = 0; x = 0; y = 0; // t1里面执行的方法不是原子性的 Thread t1 = new Thread(new Runnable() { @Override public void run() { a = 1;//1 x = b;//2 } }); // t2里面执行的方法不是原子性的 Thread t2 = new Thread(new Runnable() { @Override public void run() { b = 1;//3 y = a;//4 } }); //都可以调度 t1.start(); t2.start(); // 无法保证t1比t2先执行完 // 只能保证在执行下面的日志打印时t1和t2都执行完了，相对于主线程而言 t1.join(); t2.join(); // 得到线程执行完毕以后 变量的结果。 log.debug("第{}次输出结果：x ={}, y ={} ",count,x,y); if(x == 0 && y == 0){ break; } } } } -
x=0；y=0
-
说明CPU进行了指令重排序 — 2、4、1、3
-
因为2在1之前执行了，4在3之前执行了
-
但是如果a，b，x，y这几个变量加volatile，就不会发生指令重排了
指令重排的优点
-
重排序可以提高处理的速度（jvm线程的工作内存 — cpu核心的2级缓存）
-
x =3; load x set x store x y=4; load y sety store y x=x+6; load x set x store x -
x =3; load x set x x=x+6; set x store x y=4; load y sety store y
-
CPU进行了指令重排序例子二 — 很高的并发才会出现
- 很难复现，有两个条件
- 1.高并发
- 2.发生指令重排
单例双重校验
-
package BingFaBianCheng.bingFaBianCheng17.jmm; /** * @Author 钢牌讲师--子路 **/ public class Test5 { private static Test5 INSTANCE; private Test5() { } /** * 有线程安全问题的 * * 很高的并发-----指令重排 * @return */ // 相比getInstance2()性能要高 // 假设有10000个线程 // t1拿到锁，t2、t3、...t100阻塞 // 但是t1执行完后，就释放了锁 // t100 --- t10000 就不用加锁了 // 但是是有线程安全问题的，因为synchronozed包住的语句INSTANCE = new Test5();会发生指令重排---遇到了new关键字 // new关键字分配内存、然后在堆里面初始化，把地址赋值给INSTANCE // 如果发生指令重排---分配内存、地址赋值INSTANCE、初始化 // t1执行分配内存、地址赋值INSTANCE这两个操作后 // 发生上下文切换，t2拿到cpu资源，Instance不是null，但是没有初始化 // 所以仍然会存在线程安全问题 // 解决的方法是INSTANCE加volatile关键字 public static Test5 getInstance() { if (INSTANCE == null) { // synchronized原子性 但是也会发生线程切换， // synchronized包住的代码可能没有执行完 // 原子性不是不能发生线程切换，而是不会受到其他线程的干扰 synchronized (Test5.class){ if(INSTANCE == null){ //指令重排 /** * 分配内存 * * 地址赋值INSTANCE * * 初始化 */ INSTANCE = new Test5(); } } } return INSTANCE; } /** * 不推荐，效率低 * @return */ // 假设10000个不同的线程进来 // 实际就变成串行了，一个一个线程的进行 public synchronized static Test5 getInstance2() { if (INSTANCE == null) { INSTANCE = new Test5(); } return INSTANCE; } }
线程切换问题
-
加出来的结果不是一百万，上下文切换导致
-
加了volatile变量，保证了可见性，仍然不是一百万，因为i++不能保证原子性
-
i++不是原子操作，取出i的值，更新i的值，保存i的值
-
使用private AtomicInteger atomicInteger = new AtomicInteger();加出来的结果就是一百万
-
保证了可见性和原子性，因为AtomicInteger 的底层是用cas指令实现的，并且值也是volatile修饰的
-
unsafe类调用的就是cas指令
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import java.util.concurrent.atomic.AtomicInteger; /** * @Author 钢牌讲师--子路 **/ public class Test3 { public static void main(String[] args) { // 1.创建一个线程任务对象 Runnable target = new ThreadTarget(); // 2.开始100个线程对象执行这个任务。 for(int i = 1 ; i <= 100 ; i++ ) { new Thread(target,"第"+i+"个线程").start(); } } } // 线程任务类 class ThreadTarget implements Runnable{ //private AtomicInteger atomicInteger = new AtomicInteger(); // 定义一个共享变量 private volatile int count = 0 ; @Override public void run() { synchronized (this) { for (int i = 1; i <= 10000; i++) { //System.out.println(Thread.currentThread().getName() + "count =========>>>> " + count); } } } }
JAVA 内存模型
-
你已经知道，导致可见性的原因是缓存，导致有序性的原因是编译优化，那解决可见性、有序性最直接的办法就是禁用缓存和编译优化，但是这样问题虽然解决了，我们程序的性能可就堪忧了。合理的方案应该是按需禁用缓存以及编译优化（即happens-before原则）。那么，如何做到“按需禁用”呢？对于并发程序，何时禁用缓存以及编译优化只有程序员知道，那所谓“按需禁用”其实就是指按照程序员的要求来禁用。所以，为了解决可见性和有序性问题，只需要提供给程序员按需禁用缓存和编译优化的方法即可。Java 内存模型是个很复杂的规范，可以从不同的视角来解读，站在我们这些程序员的视角，本质上可以理解为，Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。具体来说，这些方法包括 volatile、synchronized 和 final 三个关键字，以及六项 Happens-Before 规则
-
为什么定义Java内存模型？现代计算机体系大部是采用的对称多处理器的体系架构。每个处理器均有独立的寄存器组和缓存，多个处理器可同时执行同一进程中的不同线程，这里称为处理器的乱序执行。在Java中，不同的线程可能访问同一个共享或共享变量。如果任由编译器或处理器对这些访问进行优化的话，很有可能出现无法想象的问题，这里称为编译器的重排序。除了处理器的乱序执行、编译器的重排序，还有内存系统的重排序。因此Java语言规范引入了Java内存模型，通过定义多项规则对编译器和处理器进行限制，主要是针对可见性和有序性
-
Java内存模型涉及的几个关键词：锁、volatile字段、final修饰符与对象的安全发布。其中：第一是锁，锁操作是具备happens-before关系的，解锁操作happens-before之后对同一把锁的加锁操作。实际上，在解锁的时候，JVM需要强制刷新缓存，使得当前线程所修改的内存对其他线程可见。第二是
volatile字段，volatile字段可以看成是一种不保证原子性的同步但保证可见性的特性，其性能往往是优于锁操作的。但是，频繁地访问 volatile字段也会出现因为不断地强制刷新缓存而影响程序的性能的问题。第三是final修饰符，final修饰的实例字段则是涉及到新建对象的发布问题。当一个对象包含final修饰的实例字段时，其他线程能够看到已经初始化的final实例字段，这是安全的
jmm问题
- java内存模型是为了屏蔽java程序在不同硬件系统上运行的差异，包括 volatile、synchronized 和 final 三个关键字，以及六项 Happens-Before 规则
关于java的hb原则
-
1、程序次序规则：在一个线程内，按照程序代码顺序，书写在前面的操作happens-before书写在后面的操作。准确地说，应该是控制流顺序而不是程序代码顺序，因为要考虑分支、循环等结构；但是这个规则是对结果负责
-
发生指令重排了，不是矛盾了吗？
-
int a = 1; int b; int c; // 发生指令重排 // 但是c和b这两条语句没有什么联系 // 即使交换后，跟没交换相比结果也是一样的 int a = 1; int c; int b;
-
-
2、一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是同一个锁，而"后面"是指时间上的先后顺序
-
Thread thread1; Thread thread2; // t1、t2 编译器---标准（遵守happens-before原则） // 先是t1进来，解锁 // t2进来加锁，所以t2可以看到t1解锁之后的所有操作 synchronized(test6.class){ // shard update } -
多线程加10000结果是正确的
- 1.synchronized加锁保证了可见性（这里hp的第二条规则）
- 2.synchronized加锁保证了原子性（保证内部代码不会受外界干扰）
-
-
3、volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的"后面"同样是指时间上的先后顺序
- volatile保证可见性的依据
- 怎么做到可见性的？— 内存屏障（hotspot）
- 1.happens-before原则第三条
- 2.hotspot使用的是内存屏障
-
4、线程启动规则：Thread.start()方法happen—before调用用start的线程前的每一个操作
- 调用t1.start()方法的主线程在调用t1.start()之前的操作对t1.start()方法里面的操作可见
-
5、线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join（）方法结束、Thread.isAlive（）的返回值等手段检测到线程已经终止执行
- 线程内部的软方法对Thread.join()、Thread.isAlive()可见
-
6、Happens-Before具备传递性
-
package BingFaBianCheng.bingFaBianCheng17.jmm; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * @Author 钢牌讲师--子路 **/ @Slf4j(topic = "e") public class Test6 { //hotspot 某种技术 可见性 // J9 static int a=0; static volatile boolean flag =false; @SneakyThrows public static void main(String[] args) { Thread thread = new Thread(() -> { try { while (true) { a = 50; flag = true; } }catch (Exception e){ e.printStackTrace(); } }); thread.start(); TimeUnit.SECONDS.sleep(1); // 如果想验证，可以去下载JDK4---没有hb传递性 // 传递性影响的是变量a，线程thread修改了a，不一定对主线程可见，因为没有加volatile修饰 // 因为flag是volatile，写操作要hb于读 // 用volatile作为一个触发器 log.debug("a:{},flag:{}",a,flag); for(;;){ if(a==50){ log.debug(""+a); thread.interrupt(); break; } } } }
-
扫一扫
508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
