一、可见性
public class SynctestApplication {
//底层使用了lock指令实现锁缓存行
//-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
private volatile boolean flag = true;
public void refresh() {
flag = false;
System.out.println(Thread.currentThread().getName() + "fix flag");
}
public void load() {
System.out.println(Thread.currentThread().getName() + "start------");
int i = 0;
while (flag) {
i++;
/**
* 1、第一种情况，当线程B睡了两秒钟，修改了flag的值，但是A线程还在循环，并没有退出while循环 ---- 不能
*/
//什么也不做
/**
* 2、睡一秒,跳出了while循环 ------ 能
* 不释放锁，让出cpu时间片，有线程上下文的切换
*/
/*try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
/**
* 3、println，也可以跳出while循环 -------- 能
* synchronized 可见性保证 内存屏障
*/
//System.out.println("-----------");
/**
* 4、shortWait()休眠纳秒
*/
//休眠1秒 ----- 能
//shortWait(1000000); 缓存是否失效，线程栈中的缓存有个过期时间
//休眠0.1秒 ---- 不能
//shortWait(1000);
}
System.out.println(Thread.currentThread().getName() + "jump for: i= " + i);
}
public static void main(String[] args) {
SynctestApplication test = new SynctestApplication();
new Thread(() -> test.load(), "threadA").start();
try {
Thread.sleep(2000);
new Thread(() -> test.refresh(), "threadB").start();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//1毫秒=1000微秒 1毫秒=1000 000纳秒
public static void shortWait(long interval) {
//nanoTime()返回的是纳秒
long start = System.nanoTime();
long end;
do {
end = System.nanoTime();
} while(start + interval >= end);
}
}
上图中是硬件架构，其实JMM内存模型和这个模型是一样的，只不过JMM操作的各个逻辑块，其实底层都是和上面的各个硬件有映射关系。
volatile的可见性其实就是利用了缓存一致协议（锁缓存行）（MESI）（M：修改 <----E：独占 <---- S：共享 <---- I：失效）。多个线程共享一个变量的时候，会将共享变量缓存到自己的缓存栈中，当当前这个变量是被valatile修饰的时候，那个这个变量所在的缓存行，就会被上面的MESI四种状态所标记，当前就会保证只要有一个线程修改了共享变量，总线利用总线嗅探会监测到当前的变化，并把其它缓存中的该变量的状态修改为I无效，其它线程如果需要获取该变量，都需要重新从主存中读取数据。
修改当前缓存中的共享变量对于当前线程来说是线程安全的，但是对被volatile修饰的变量来说，多个线程共同操作这个变量的时候，这个过程就不是线程安全的，所以volatile并不是线程安全的。下面是一个例子
private static volatile long sum = 0;
public static void main(String[] args) {
for (int i=0; i<5; ++i) {
new Thread(()->{
for (int j=0; j<1000; ++j) {
sum++;
}
}).start();
}
System.out.println(sum);//sum每次输出来的值，都不是我想要的
}
注意：如果多个核的线程在操作同一个缓存行中的不同变量数据，那么就会出现频繁的缓存失效，即使在代码层面看这两个线程操作的数据之间完全没有关系。这种不合理的资源竞争情况就是伪共享
public class FalseSharing {
public static void main(String[] args) {
try {
testPointer(new Pointer());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static void testPointer(Pointer pointer) throws InterruptedException {
long start = System.currentTimeMillis();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100000000; i++) {
pointer.x++;
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100000000; i++) {
pointer.y++;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(System.currentTimeMillis() - start);
}
}
class Pointer {
/**
* 伪共享，缓存行一般是占用64个字节，下面的x和y总共占用的是8+8=16个字节，当两个线程分别对x和y进行修改时，会造成当前缓存行频繁失效，得不停地从主存中读取数据
* 这样就会对性能有所损耗
*
* 改进策略，浪费空间换取时间的策略，补齐64字节，让x和y分别在两个缓存行，这样在锁缓存行的时候，就不会出现频繁缓存行失效的情况
*/
public volatile long x;
public long a,b,c,d,e,f,g;//避免伪共享，加上x刚好是64字节，没加这一行，执行时间大概是3秒，加了以后，执行时间是0.5毫秒
public volatile long y;
}
二、有序性（实现了相当于内存屏障的功能）
public class ReOrder {
//保证有序性，禁止重排序
private volatile static ReOrder myInstance;
public static ReOrder getMyInstance() {
if (myInstance == null) {
synchronized (ReOrder.class) {
if (myInstance == null) {
/**
* 单线程下，如果把2和3调换顺序，不会出现什么问题
* 1、分配内存空间
* 2、对象进行初始化
* 3、将地址赋值给myInstance
*
*
* 多线程的情况下
* 1、分配内存空间
* 3、将地址赋值给myInstance
* 2、对象进行初始化
* 当执行完第二步的时候，myInstance已经有值了，此时，如果第二个线程进入到getmyInstance方法里面，第一个判断结果就会返回false，
* 直接将myInstance的值返回，那么此时，就有可能对一个未初始化的对象做操作，那么加上volatile就可以防止，指令排序，2和3的位置也不会被调换
*/
myInstance = new ReOrder();
}
}
}
return myInstance;
}
public static void main(String[] args) {
ReOrder.getMyInstance();
}
}
为什么会有重排序呢？？？
从上图中可以看出来（1）（2）执行的结果都一样，但是对应的数据加载的指令却不一样，一个load代表从内存中加载一次数据通过高速缓存到cpu的过程，如果有重排序，那么就会减少一次这样的过程，这样的性能就比较高
