Java多线程之内存可见性
什么叫“可见性”？
一个线程对共享变量值的修改，能够被其他线程及时看到。
共享变量：如果一个变量在多个线程的工作内存中存在副本，那么这个变量就是这几个线程的共享变量。
所有变脸都存在主内存中，每个线程都有自己独立的工作内存，里面保存该线程使用大的变量副本，关系如下图所示：
多线程遵守的两条规定
1.线程对共享变量所有的操作都只能在自己的工作内存中完成，无法直接从主内存中读写
2.不同线程之间无法访问其他线程中的变量，线程中变量值的传递需要通过主内存来完成。
共享变量可见性的实现原理
线程1对共享变量的修改如果要被线程2及时看到，需要经过2个步骤：
1.把工作内存1中更新过的共享变量值刷新到主内存中
2.把主内存中最新的共享变量的值更新打工作内存2中
以上2个步骤，任意一个出现问题，都会导致共享变量无法被其他线程及时看到，无法实现可见性，导致其他线程读取的数据不准确从而产生线程不安全。
共享变量可见性的实现方式
Java语言层面支持的可见性实现方式有2种,分别是synchronized、volatile。
synchronized：能够实现原子性（同步）和可见性
volatile：能够保证可见性，但是无法保证原子性
synchronized是如何实现可见性？
java内存模型（JMM）中关于synchronized的两条规定：
1).线程解锁前，必须把共享变量的最新值刷新到主内存中
2).线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新值（注意：加锁与解锁需要是同一把锁）
线程执行互斥代码的过程
1.获得互斥锁
2.清空工作内存
3.从主内存拷贝变量的最新副本到工作内存中
4.执行代码
5.将更改后的共享变量值刷新到主内存中
6.释放互斥锁
指令重排序
代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或者处理器为了提高程序性能而做的优化。
目前的指令从排序有3种方式：
1.编译器优化的重排序（编译器优化）
2.处理器优化的重排序（处理器优化）
3.内存优化的重排序（处理器优化）
as-if-serial
无论如何重排序，程序执行的结果都应该与代码顺序执行的结果一致（java编译器和处理器运行时都会保证在单线程中遵循as-if-serial规则，多线程存在程序交错执行时，则不遵守）
举例：
int num1 = 1;
int num2 = 2;
int num3 = num1 + num2;
上面3行代码，在单线程时，第1、2行可以进行重排序，但是第3行不可以，否则结果将不一样，所以从排序不会给单线程带来内存可见性的问题。
而在多线程中，程序交错执行时，重排序则会造成内存可见性的问题。
Synchronized实现可见性的代码，以下的这个类SynchronizedDemo
public class SynchronizedDemo { // 共享变量 private boolean ready = false; private int num = 1; private int result = 0; // 写操作 public void write() { ready = true; // 1.1 num = 2; // 1.2 } // 读操作 public void read() { if (ready) { // 2.1 result = num * 3; // 2.2 } System.out.println("result = " + result); } private class ReadWriteThread extends Thread { private boolean flag; public ReadWriteThread(boolean flag) { this.flag = flag; } @Override public void run() { if (flag) { write(); } else { read(); } } } public static void main(String[] args) { SynchronizedDemo synchronizedDemo = new SynchronizedDemo(); synchronizedDemo.new ReadWriteThread(false).start(); synchronizedDemo.new ReadWriteThread(true).start(); } }
上面的这一段代码重排序后的执行顺序可能是
1. 1.2-->2.1-->2.2-->1.1; result=0
2. 1.1-->2.1-->2.2-->1.2; result=3
......
导致共享变量在线程之间不可见的原因
1.线程的交叉执行
2.重排序结合线程交叉执行
3.共享变量更新后的值，没有在工作内存与主内存间及时刷新
安全的代码，加入synchronized关键字
// 写操作 public synchronized void write() { ready = true; // 1.1 num = 3; // 1.2 } // 读操作 public synchronized void read() { if (ready) { // 2.1 result = num * 2; // 2.2 } System.out.println("result = " + result); }
volatile是如何实现可见性？
深入来说，是通过加入内存屏障和禁止重排序优化来实现的。
对volatile变量执行写操作时，会在写操作后加入一条store屏障指令，会将cup数据强制刷新到主内存中去
对volatile变量执行读操作时，会在读操作前加入一条load屏障指令，强制缓存器中的缓存失效，每次使用都要去主内存中重新获取数据
通俗地讲，volatile变量在每次被访问的时候，都强迫从主内存中读取该变量的值，而当该变量在发生变化时，又会强迫变量讲最新的值刷新到主内存中，这样，任意时刻，不同的线程总能看到该变量的最新值。
线程写volatile变量的过程：
1.改变线程工作内存中volatile变量副本的值
2.将改变的副本的值从工作内存中刷新到主内存中
线程读volatile变量的过程：
1.从主内存中读取volatile变量的最新值到工作内存中
2.从工作内存中读取volatile变量的副本
volatile不能保证原子性，请看下面的代码：
public class VolatileDemo { private volatile int num = 0; public int getNum() { return this.num; } public void increase() { // num++，不是原子操作，这里会先读取，再加1 this.num++; } public static void main(String[] args) { final VolatileDemo volatileDemo = new VolatileDemo(); // 创建500个子线程，执行increase方法，每次都让num加1 for (int i = 0; i < 500; i++) { new Thread(new Runnable() { @Override public void run() { volatileDemo.increase(); } }).start(); } // 等到所有子线程执行完毕，eclipse这里是1，IntelliJ IDEA执行用户代码的时候，实际是通过反射方式去调用，而与此同时会创建一个Monitor Ctrl-Break 用于监控目的，所有是2 while (Thread.activeCount() > 2) { Thread.yield(); } // 由于num使用了volatile关键字，所以预期值应该是500 System.out.println("当前的num值=" + volatileDemo.getNum()); } }
执行后，会发现，有时候不是500，而是499或者498或者497等等，原因是num++不是原子操作，volatile只能保证变量修改后的可见性，但是无法保证原子性，请看下面的步骤：
假设现在num=5
1.线程A读取num的值，线程A的工作内存中，num=5
2.线程B也读取了num的值，线程B的工作内存中，num=5
3.线程B进行加1操作，线程B的工作内存中，num=6
4.线程B写入最新的num值，主线程中num的值变为6
5.线程A执行加1操作，线程A的工作内存中，num=6
6.线程A写入最新的num值，主线程中num的值变为6
这样，两个线程各自执行了一次加1操作，但是主线程中的数据num=6,这就是由于volatile没办法保证代码的原子性，使得读和写不是一起的
解决方案：
1.使用synchronized关键字
2.使用ReentrantLock
3.使用AtomicInteger
volatile的适用场景
1.对变量的写入操作不依赖其当前值
不满足：num++、count = count * 5
满足：boolean值变量，记录温度变化的变量等等
2.该变量没有包含在具有其他变量的不变式中
不满足：low < up
一般的应用场景很多会不满足其中一个，所以volatile是使用没哟synchronized这么广泛。
synchronized与volatile比较
1.volatile不需要加锁，比synchronized更轻量级，不会阻塞线程
2.从内存的角度，volatile读操作相当于加锁，写操作相当于解锁
3.synchronized既能保证原子性又能保证可见性，而volatile只能保证可见性无法保证原子性
