CPU内部结构划分
控制单元
运算单元
存储单元
第一节: JMM内存模型、CPU缓存一致性原则(MESI)、volatile、指令重排、内存屏障(Memory Barrier)、as-if-serial、happen-before原则 计算机多硬件多CPU结构：
第一节: JMM内存模型、CPU缓存一致性原则(MESI)、volatile、指令重排、内存屏障(Memory Barrier)、as-if-serial、happen-before原则 CPU缓存一致性原则
JMM同步八种操作介绍：
（1）lock(锁定)：作用于主内存的变量，把一个变量标记为一条线程独占状态
（2）unlock(解锁)：作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的 变量才可以被其他线程锁定
（3）read(读取)：作用于主内存的变量，把一个变量值从主内存传输到线程的工作内存中， 以便随后的load动作使用
（4）load(载入)：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作 内存的变量副本中
（5）use(使用)：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎
（6）assign(赋值)：作用于工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量
（7）store(存储)：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作
（8）write(写入)：作用于工作内存的变量，它把store操作从工作内存中的一个变量的值传送 到主内存的变量中
如果要把一个变量从主内存中复制到工作内存中，就需要按顺序地执行read和load操作， 如果把变量从工作内存中同步到主内存中，
就需要按顺序地执行store和write操作。但Java内 存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
第一节: JMM内存模型、CPU缓存一致性原则(MESI)、volatile、指令重排、内存屏障(Memory Barrier)、as-if-serial、happen-before原则 JMM三大特性
原子性
汇编指令 --原子比较和交换在底层的支持 cmp-chxg
解决办法: Synchronized Lock锁机制 保证任意时刻只有一个线程访问该代码块。 public class VolatileAtomicSample {
private static volatile int counter = 0; // volatile无法保证原子性
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(()->{
for (int j = 0; j < 1000; j++) {
counter++; //不是一个原子操作,第一轮循环结果是没有刷入主存，这一轮循环已经无效
//1 load counter 到工作内存
//2 add counter 执行自加
}
});
thread.start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(counter);
}
} 启动10个线程，每个线程执行自增步骤，count++ 是非原子性的。volatile保证数据的可见性，同时存在CPU缓存锁机制以及MESI缓存分布式协议，最后打印的值 <= 10000.
CPU为了提升性能，会存在指令编排机制。也就会出现内存屏障 见有序性详解。
可见性 volatile -- LOCK缓存行(有且仅有一个线程会占有缓存行) + CPU缓存一致性原则MESI(独占E-->共享S-->修改M--->其他失效I) public class VolatileVisibilitySample {
private boolean initFlag = false;
public void refresh(){
this.initFlag = true; //普通写操作，(volatile写)
String threadname = Thread.currentThread().getName();
System.out.println("线程："+threadname+":修改共享变量initFlag");
}
public void load(){
String threadname = Thread.currentThread().getName();
int i = 0;
while (!initFlag){
i++;
}
System.out.println("线程："+threadname+"当前线程嗅探到initFlag的状态的改变"+i);
}
public static void main(String[] args){
VolatileVisibilitySample sample = new VolatileVisibilitySample();
Thread threadA = new Thread(()->{
sample.refresh();
},"threadA");
Thread threadB = new Thread(()->{
sample.load();
},"threadB");
threadB.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
threadA.start();
}
} 分析如下: 只会打印 "线程：threadA:修改共享变量initFlag".
修改：
因为在线程A里面增加了锁机制，同时CPU自身也存在时间片切片，导致线程上下文切换，initFlag会从内存中读取线程B更新的值。
会把线程B嗅探机制打印出来。打印如下：
线程：threadA:修改共享变量initFlag
线程：threadB当前线程嗅探到initFlag的状态的改变25747425
修改2：使用volatile关键字 ====> JMM缓存一致性原则(MESI) + LOCK缓存行
有序性
-- 指令重排 ---> 内存屏障（volatile禁止重排优化 ） 查看汇编指令:-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
as-if-serial语义的意思是:不管怎么重排序(编译器和处理器为了提高并行度),(单线程)。 即在单线程情况下，不能改变程序运行的结果 程序的执行结果不能被改变。编译器、runtime和处理器都必须遵守as-if-serial语义。
double p = 3.14; //1
double r = 1.0; //2
double area = p * r * r; //3计算面积 上面例子中1,2存在指令重排操作，但是1,2不能和第三步存在指令重排操作，否则将改变程序运行的结果。
happen-before原则
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()方法的调用先行发生于被中断线程的代码检测到中断事件的发生 8、对象终结规则 对象的构造函数执行，结束先于finalize()方法
指令重排发生在什么阶段？
1. 编译阶段，字节码编译成机器指令码阶段。
2. CPU运行时，执行指令
volatile禁止重排优化 ---内存屏障(Memory Barrier)
下图是JMM针对编译器制定的volatile重排序规则表 指令重排code示例 /**
* 并发场景下存在指令重排
*/
public class VolatileReOrderSample {
private static int x = 0, y = 0;
private static volatile int a = 0, b =0;
static Object object = new Object();
public static void main(String[] args) throws InterruptedException {
int i = 0;
for (;;){
i++;
x = 0; y = 0;
a = 0; b = 0;
Thread t1 = new Thread(new Runnable() {
public void run() {
//由于线程one先启动，下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
shortWait(10000);
a = 1; //是读还是写？store，volatile写
//storeload ,读写屏障，不允许volatile写与第二步volatile读发生重排
x = b; // 读还是写？读写都有，先读volatile，写普通变量
//分两步进行，第一步先volatile读，第二步再普通写
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
public void run() {
b = 1;
UnsafeInstance.reflectGetUnsafe().storeFence();
y = a;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
/**
* cpu或者jit对我们的代码进行了指令重排？
* 1,1
* 0,1
* 1,0
* 0,0
*/
String result = "第" + i + "次 (" + x + "," + y + "）";
if(x == 0 && y == 0) {
System.err.println(result);
break;
} else {
System.out.println(result);
}
}
}
public static void shortWait(long interval){
long start = System.nanoTime();
long end;
do{
end = System.nanoTime();
}while(start + interval >= end);
}
} 如果不要volatile去增加内存屏障？如何解决？
-- 手动增加屏障，通过Unsafe来解决. loadFence() storeFence fulFence() .
Unsafe通过BootStwp被加载，否则抛异常。JVM的双亲委派机制
通过反射来获取。 public class UnsafeInstance {
public static Unsafe reflectGetUnsafe() {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
} 内存屏障 Memory Barrier 1.写写storestore 2.写读storeload 3.读写loadstore 4.读读loadload volatile禁止重排优化
volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序 执行的现象，关于指令重排优化前面已详细分析过，这里主要简单说明一下volatile是如何实 现禁止指令重排优化的。先了解一个概念，内存屏障(Memory Barrier）。
内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执行 顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于编译 器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器 和CPU，
不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏 障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用是强制刷出 各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的新版本。总之， volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化。
下面看一 个非常典型的禁止重排优化的例子DCL，如下：
public class DoubleCheckLock {
private static DoubleCheckLock instance;
private DoubleCheckLock(){}
public static DoubleCheckLock getInstance(){ //第一次检测
if (instance==null){ //同步 synchronized (DoubleCheckLock.class)
{ if (instance == null){ //多线程环境下可能会出现问题的地方
instance = new DoubleCheckLock();
}
}
}
return instance;
}
} 上述代码一个经典的单例的双重检测的代码，这段代码在单线程环境下并没有什么问题， 但如果在多线程环境下就可以出现线程安全问题。原因在于某一个线程执行到第一次检测，读 取到的instance不为null时，instance的引用对象可能没有完成初始化。
总线风暴
问题：大量使用cas和volatile，会有什么问题? 高并发情况下为什么会产生总线风暴?
1. CAS ---> CPU工作内存与主内存产生大量的交互
2. volatile ---> 产生大量的无效的工作内存变量
第一节: JMM内存模型、CPU缓存一致性原则(MESI)、volatile、指令重排、内存屏障(Memory Barrier)、as-if-serial、happen-before原则 解决办法:
synchronized 关键字
单例设计---高并发(加双重锁)
public class Singleton {
/**
* 查看汇编指令
* -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
*/
private volatile static Singleton myinstance;
public static Singleton getInstance() {
if (myinstance == null) {
synchronized (Singleton.class) {
if (myinstance == null) {
myinstance = new Singleton();//对象创建过程，本质可以分文三步
//对象延迟初始化
//
}
}
}
return myinstance;
}
public static void main(String[] args) {
Singleton.getInstance();
}
} 第一节: JMM内存模型、CPU缓存一致性原则(MESI)、volatile、指令重排、内存屏障(Memory Barrier)、as-if-serial、happen-before原则