遇到的问题
cpu在执行指令，处理运算的过程中，总会涉及到数据的读取和写入。数据是放在内存中的，由于cpu的速度太快，内存速度跟不上，致使cpu的等待时间变长。因此cpu中引入了高速缓存。
引入了缓存后的数据的流向为:
现在基本都是多核处理器，所以画了三个cpu代表cpu的三个核。虽然给每个核引入了高速缓存来加快每个核的读取数据的速度，但是却引起了一个很严重的问题--缓存不一致。
假设内存中有个变量a，初始化值为0。现在要求三个cpu对变量a进行递增操作。这个时候三个cpu会将内存中的a首先加载到高速缓存中：
然后三个cpu读取缓存中的值进行递增操作，然后再刷新会自己的缓存中：
最后将各个cpu缓存中a的值刷新会内存，这时候问题就出现了，虽然cpu对a进行了三次递增，但是当cpu将各自缓存中值更新回内存的时候会覆盖之前的值，所以内存中的a的值最终为1。这就是缓存不一致导致了最终数据不一致。
解决办法
对于这个问题，硬件层面和软件层面都提供了一些解决方案，这次我们说的是java中解决这个问题的一个关键字--volatile。
原理解释
几个并发的概念。
- 原子性
在java中对于变量的读或者写是原子性的，它们的特点是这些操作要么不执行，要么就一次执行完，中间是不能被打断的。
一定要知道读和写是两个操作，比如下面两个例子：
int i = 1; // 操作一
i++; // 操作二
在上述两个操作中操作一时原子性，他是直接给一个变量赋值，但是操作二不具有原子性，因为cpu会首先会读取i的值，然后将其进行递增操作后再刷新回内存。这中间就涉及了多个操作（读-处理-写），其中任何一个操作执行完后都有可能被打断，所以操作二不具备原子性。
- 可见性
在开篇的几幅图中可以知道，各个cpu的缓存之间是不可见的，当其中一个cpu将a值递增之后，其他cpu并不知道a值已经改变，还是按照自己缓存中的值进行操作，这是因为各个cpu的缓存间不可见的。而volatile就可以保证可见性：当cpu改变了a的值后会立即刷新回内存中去，并且使其他cpu对a值的缓存失效，强制去内存中读取最新的值。 - 有序性
为了优化cpu执行速度，编译器或者处理器会对指令进行排序，这时候指令的执行顺序可能就和手写的代码顺序不一样了。而volatile可以保证指令执行的有序性。
volatile关键字
语义
被volatile修饰的变量会具备两层语义：
- 保证该变量在不同线程间是
可见的。即，这个变量被一个线程修改，那其他线程是可以立即知道的。 - 禁止指令重排序
证明
先来测试一下没有volatile修饰的变量代码：
创建一个测试类Test:
public class Test {
private static int PUBLIC_NUM = 0;
public static void main(String[] args) {
new ChangeListener().start();
new ChangeMaker().start();
}
static class ChangeListener extends Thread {
@Override
public void run() {
int localValue = PUBLIC_NUM;
while (localValue < 5) {
if (localValue != PUBLIC_NUM) {
System.out.println("已经检测到 PUBLIC_NUM 的改动 : " + PUBLIC_NUM);
localValue = PUBLIC_NUM;
}
}
}
}
static class ChangeMaker extends Thread {
@Override
public void run() {
int localValue = PUBLIC_NUM;
while (PUBLIC_NUM < 5) {
System.out.println("开始递增 PUBLIC_NUM 为 : " + (localValue + 1));
PUBLIC_NUM = ++localValue;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
上述代码中创建了两个线程，一个线程对PUBLIC_NUM变量进行递增操作，一个线程执行一个while循环，若线程间没有可见性，则ChangeListener线程无法检测到PUBLIC_NUM的改动，若线程间具有可见性，则会检测到改动。
首先是没有加volatile的结果：
可以看到ChangeListener线程没有检测到PUBLIC_NUM的改动。接下来是加了volatile的结果：
加了volatile关键字后ChangeListener线程能检测到PUBLIC_NUM的改动了，说明了volatile关键字可以实现可见性。被volatile修饰的变量在并发条件下如果被一个线程修改，其他拥有此变量的线程会被强制性的去主存中更新自己的变量值副本。
上面说明了可见性，接下来来说明另一个语义-禁止指令排序。创建一个Test1类：
public class Test1 {
static int x,y,m,n;//测试用的信号变量
public static void main(String[] args) throws InterruptedException {
int count = 10000;
for(int i=0;i<count;++i){
x=y=m=n=0;
//线程一
Thread one = new Thread(){
@Override
public void run() {
m=1;
x=n;
};
};
//线程二
Thread two = new Thread(){
@Override
public void run() {
n=1;
y=m;
};
};
//启动并等待线程执行结束
one.start();
two.start();
one.join();
two.join();
//输出结果
System.out.println("index:"+i+" {x:"+x+",y:"+y+"}");
}
}
}
可以看到打印出来的x和y的值不是绝对一样的，这就说明两个线程对变量的赋值操作顺序做了调整，也就是将指令重新排序了。这样做可能会导致一些严重的后果，比如说下面这个伪代码：
//线程1:
context = loadContext(); //语句1
inited = true; //语句2
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);
若指令重排了导致inited先赋值为true，那线程2获取到context的值可能为null，这样会导致doSomethingwithconfig这个方法报错。如果用volatile来修饰变量，就会禁止指令重新排序，保证代码执行结果。
volatile会保证原子性吗？
前面说了volatile可以保证代码执行顺序和可见性，那会保证原子性吗？答案是不会！可能会问前面不是说了一个线程对变量的修改会导致其他线程去更新缓存中的值吗，这样不就是保证了每次更新都是对的？
让我们来跑一段代码：
public class Test3 {
volatile static int a = 0;
public static void main(String[] args) {
for (int i=0;i<1000;i++) {
new Thread() {
@Override
public void run(){
a++;
}
}.start();
}
System.out.println("最终结果： "+a);
}
}
我执行了10次左右，基本每次都是小于1000的，这说明了volatile并不能保证原子性！
为什么！
java语言的指令集是一门基于栈的指令集架构。也就是说它的数值计算是基于栈的。比如计算inc++,翻译成字节码就会变成：
0: iconst_1
1: istore_1
2: iinc 1, 1
0：的作用是把1放到栈顶
1：的作用是把刚才放到栈顶的1存入栈帧的局部变量表
2：的作用是对指令后面的1 ，1相加
由第0：步可以看到，当指令序列将操作数存入栈顶之后就不再会从缓存中取数据了，那么缓存行无效也就没有什么影响了。
意思就是在缓存失效的时候，这个变量的数据已经加载进寄存器中了，缓存失效与否与其无关，cpu可以对旧的数据继续进行操作。
