Volatile

什么是Volatile

首先它是一个关键字，它不是Java语言首创，早在C和C++中就已经存在了。

特性

1. 可以保证可见性
2. 禁止指令重排序
3. 不能保证原子性

JMM

我们在讨论Volatile的时候肯定离不开JMM，什么是JMM呢？java内存模型简称JMM（Java Memory Model），是java虚拟机所定义的一种抽象规范，用来屏蔽不同硬件和操作系统的内存访问差异，让Java程序在各种平台下都能够达到一致的内存访问效果。

这里需要明确几个概念？

主内存：

主内存其实可以简单的理解为计算中的内存，但是又不完全等同。主内存中的数据会被所有线程所共享，对于一个共享变量（比如：静态变量，或者是堆内存中的实例等）来说，主内存中存储的是数据本身。

工作内存：

工作内存可以简单的理解为计算机中CPU的高速缓存，但有不完全等同。每一个线程都拥有自己的工作内存，对于一个共享变量来说，工作内存中存储的是它的“副本”。

线程对共享变量的操作

线程对共享变量的所有操作都必须在工作内存中进行，不能直接读写内存中的变量。不同线程之间是不能访问彼此之间的工作内存，变量值的传递只能通过主内存。

实例说明：

对于一个静态变量：
static int s = 0;
线程A执行如下代码：
s = 3;

工作流程图所示：

线程A操作：




通过一系列的内存读写的操作指令（JVM内存模型共定义了8中内存操作指令），线程A把静态变量S = 0 从主内存中读到工作内存中，再把s = 3 的更新结果同步到主内存中。如果仅仅从单线程的角度来看，它不会存在任何问题

线程B：
这时候我们再引入一个线程B，执行如下的代码：
System.out.println("s=" + s);最终的打印结果可能有两种情况① s = 0; ② s = 0;
引用了线程B以后，线程A先执行，待线程A将s = 3 更新到了主内存后，线程B读取了数据。所以线程B输出的结果是：s = 3

**下面这种情况是：线程A还没有将s = 3同步回主内存，线程B就去主内存中读取数据了，所以最终线程B输出的结果为：s = 0

出现上述情况的原因是：因为工作内存所更新的数据并不会立即同步到主内存中，所以线程A虽然在工作内存中更新了s = 3，但是线程B从内存中得到的变量s的值仍然是0。

那应该如何解决这个问题呢？答案是可以加Volatile关键字，为什么加了这个关键字就可以实现了呢？答案是：因为这个关键字中的一些特性决定的（可见性、禁止指令从排序）。

这里的可见性是什么意思呢？

当一个线程修改了变量的值，新的值会立刻同步到主内存当中。而其他线程读取这个变量的时候，也会从主内存拉取最新的变量值。
那为什么Volatile有这样的特性呢？这就要得益于Java语言的先行发生原则（happens - before）了。
先行发生原则：
维基百科：在计算机科学中，先行发生原则是两个事件的结果之间的关系，如果一个事件发生在另一个事件之前，结果必须反映，即使这些事件实际上是乱序执行的（通常是优化程序流程）。
这里所谓的事件，实际上就是各种指令操作，比如：读操作、写操作、初始化操作、锁操作等待。
先行发生原则作用于很多场景下：包括同步锁、线程启动、线程终止、volatile。这里只列举了volatile的相关规则：

回到上述的实例：

volatile static int s = 0;
线程A执行如下代码：
s = 3;
这时候线程B，执行如下代码：
System.out.println("s = " + s );
当线程A先执行的时候，把 s = 3 写入主内存的事件必定会先于读取 s 的事件。所以线程B的输出一定是 s = 0;

Volatile无法保证原子性的实例：

public class VolatileTest {
	public volatile static int count = 0;
	public void main(String [] args){
		//开启十个线程
		for(int i = 10;i<10;i++){
			new Thread(
				new Runnable(){
					public void run(){
						try{
							Thread.sleep(1);
						}catch(InterruptedException e){
							e.printStackTrace();
						}
						//每个线程当中让count值自增100次
						for(int j = 0;j < 100;j++){
							count ++;
						}
					}
				}
			).start();
		}
		try{
			Thread.sleep(2000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.print("count=" + count);
	}
}

这段代码是什么意思呢？很简单，开启10个线程，每个线程当中让静态变量count自增100次。执行之后会发现，最终count的结果值未必是1000，有可能小于1000。

为什么不能保证原子性：

使用volatile修饰的变量，为什么并发自增的时候会出现这样的问题呢？这是因为count++这一行代码本身并不是原子性操作，在字节码层面可以拆分成如下指令：

getstatic        //读取静态变量（count）
iconst_1        //定义常量1
iadd               //count增加1
putstatic        //把count结果同步到主内存

虽然每一次执行 getstatic 的时候，获取到的都是主内存的最新变量值，但是进行iadd的时候，由于并不是原子性操作，其他线程在这过程中很可能让count自增了很多次。这样一来本线程所计算更新的是一个陈旧的count值，自然无法做到线程安全