关键知识点：
happens-before原则，JVM指令重排序，主存和工作内存
本文基于已经理解了Java内存模型和并发编程的三个概念：原子性，有序性，可见性。
先说结论：
volatile的两大特性：内存可见性，禁止重排序
volatile用于修饰变量，能保证修饰变量的可见性和有序性，但不能保证原子性（重要）。
volatile 使用场景
syhchronized关键字，是防止多个线程同时执行一段代码。需要获取到对象的锁进行同步，这样就很影响执行效率。而在某些特定的场景中，使用volatile可以带来更好的性能，在这样的场景下，volatile相当于一个轻量级的synchronized功能，因为volatile不会引起线程的上下文切换。
但是一定要注意，volatile并不能代替synchronized，它并不能保证操作的原子性。正确使用volatile需要满足两个条件：
- 对变量的写操作，不依赖于当前值。
- 该变量没有包含在其他变量的不变式中。
以上的这些条件表明，可以被写入volatile变量的这些有效值，独立于任何程序的状态，包括当前的状态。
第一个条件比较好理解，它限制了volatile变量不能用作线程安全的计数器操作，例如a++这样的操作，事实上需要先获取当前a的值，然后再+1，最后再赋值给a，三步操作。这样的情况volatile不适用。
第二条，简单理解来说就是，不要包含到其他变量的不变式作为判断条件。例如如下代码（引用自参考文章）：
public class NumberRange {
private volatile int lower = 0;
private volatile int upper = 10;
public int getLower() { return lower; }
public int getUpper() { return upper; }
public void setLower(int value) {
if (value > upper)
throw new IllegalArgumentException(...);
lower = value;
}
public void setUpper(int value) {
if (value < lower)
throw new IllegalArgumentException(...);
upper = value;
}
}
在上述代码中，上下界的初始值为(0,10)，如果setLower(8)和setUpper(5)被两个线程同时执行，并且同时通过了判断条件，然后再给相应变量赋值，就出现了(8,5)这个无效的范围。这个时候就需要一个同步方法，保证setLower()和setUpper()同一时间只能执行一次。
接下来举两个volatile常见的使用场景栗子：
- 状态标记位
volatile boolean flag = false;
//线程1
while(!flag){
doSomething();
}
//线程2
public void setFlag() {
flag = true;
}
根据状态标记设置为volatile，使得更改始终可见，及时终止线程。
- Java Atominc相关类
例如，AtomicInteger 中 value的保存，以下是该类部分源码
//unsafe对象，用于CAS操作
private static final Unsafe unsafe = Unsafe.getUnsafe();
//value在主存中的偏移地址，修改值操作时，由unsafe根据valueOffset可以获取到value存储的地址，从而直接操作内存进行CAS操作。
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//保存当前结果值
private volatile int value;
//指定初始值构造器
public AtomicInteger(int initialValue) {
value = initialValue;
}
- 懒汉单例模式的double check
此处给变量加上volatile关键字，是利用了它的禁止指令重排序特性。
主要在于instance = new Singleton()这个行代码，并非是一个原子操作，事实上在JVM中，这行代码做了三件事情：
1）给instance分配内存
2）调用Singleton构造器，在堆上分配的内存中，初始化成员变量。
3）将instance对象指向分配的内存空间（执行完这一步 instance就非null了）
但是，在JVM的JIT（即时编译器）中存在指令重排序优化，也就是说，上述指令，并不能保证按顺序执行。如果被执行的顺序是1-3-2。那么在3执行完毕2进行之前（此时变量非null），其他线程请求第一个check条件，发现非null，然后返回instance并使用，那么就会出错了。
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
syschronized(Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
不过单例模式的众多写法中，另一种饿汉式的写法更加优雅，同时，这种方式也避免了线程安全的问题，直接在类加载期间初始化单例变量。
public class Singleton {
static class SingletonHolder {
static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}
volatile 实现原理
保证可见性
处理器为了提高处理速度，不直接可内存进行通讯，而是将系统内存的数据读到内部缓存，然后再进行操作。但是操作完成后不确定什么时间会写会主存。
在多处理器环境下，为了保证各个处理器缓存一致，每个处理会通过嗅探在总线上传播的数据来检查 自己的缓存是否过期，当处理器发现自己缓存行对应的内存地址被修改了，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作时，会强制重新从系统内存把数据读到处理器缓存里。 这一步确保了其他线程获得的声明了volatile变量都是从主内存中获取最新的。
在Java内存模型中，有主存和工作内存两个概念，每个线程都有一个自己的独立工作内存，并且共享一份主存数据。基于此种模型，便产生了数据可见性的问题。
例如，下面一行代码：
//线程1执行代码
int i = 0;
i = 10;
//线程2执行代码
int j = i;
当线程1执行代码时，会先把i的值0，从主存中拿出，在自己的工作线程中，将i的值变为10。这个时候a的值变为10了，但是并没有被立即写到主存中。如果这个时候线程2执行代码，那么取到的 i 的值还是0，j就被赋值为了0。
基于以上问题的存在，
当一个变量被volatile修饰时，JVM对这个变量的读操作会把工作内存中的该值设为无效，每次请求都强制要求从主存读取。进行写操作时，JVM会保证对这个变量的修改会立即更新到主存。这种情况下，其他线程获取到的值始终都是最新的值。
保证有序性
开始提到，volatile能禁止指令重排序，从而保证一定程度上的有序性。
volatile的禁止指令重排序，有两层意思：
1）当程序执行到volatile变量的读或者写操作时，在其前面的操作和更改肯定已经全部执行，并且结果对后面的操作已经完全可见。而在其后面的操作，肯定还没有执行。
2）在进行指令优化时，不能将在对volatile变量的读操作或者写操作放到其后面执行，同时，也不能把在volatile变量后面的语句放到其前面执行。（其实就是volatile变量，始终要对其后面的操作可见）
volatile的内存可见性，是基于内存屏障（Memory Barreir）实现的，内存屏障，又称为内存栅栏，是一个CPU指令。
在程序运行时，为了提高程序性能，编译器和处理器会对指令进行重排序，JVM为了保证在不同的编译器和CPU上有相同的结果，通过插入特定类型的内存屏障来禁止特定类型的编译器重排序和处理器重排序，插入一条内存屏障会告诉编译器和CPU：不管什么指令都不能和这条Memory Barrier指令重排序。
简单举个栗子：
int x = 2;
int y = 3;
volatile boolean flag = false;
x = -1;
y = 10;
前面两行 x和y 的赋值语句，执行时是不会放到flag下执行的。1 2 行 执行顺序可以是 2 1。4 5 行执行顺序可以是5 4 。但是 1 和 2 在到达volatile变量时，肯定是执行完成的。
通过观察volatile变量和普通变量的字节码可以发现，操作volatile会多出一个lock的前缀指令。
Java代码：
instance = new Singleton();
汇编代码：
0x01a3de1d: movb $0x0,0x1104800(%esi);
0x01a3de24: **lock** addl $0x0,(%esp);
这个Lock前缀的指令，相当于上面提到的内存屏障，它保证了以下三点：
1）将当前CPU缓存行的数据写会到主存。
2）这个写会内存的操作，会导致在其他CPU里缓存了该内存地址的数据无效。
3）内存屏障的作用，确保指令重排序时，不会将其后的指令排序到之前，也不会将前面的指令排序到后面。
（如果有什么错误或者建议，欢迎留言指出）
（本文内容是对各个知识点的转载整理，用于个人技术沉淀，以及大家学习交流用）
参考资料：
Java volatile关键字解惑
importNew-volatile详解
importNew-volatile低层实现
正确使用volatile变量
