volatile的作用归结起来有两点：
1、保证内存可见性
2、防止指令重排序
但是要注意一点
保证double，float的读写的原子性，但是无法保证复合操作的原子性
分别解释：
一、 保证内存可见性
CPU和物理内存之间的通信速度远慢于CPU的处理速度，为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到主内存。
在多线程的情况下就会出现“缓存一致性”问题。
/**
*
* @author fukailong
*
*/
public class Test {
private boolean flag = false;
public void doSomethind() {
while (!flag) {
// System.out.println("执行中..");//这个位置不要打印，因为打印容易触发将线程工作内存中的变量回刷到主存中
}
System.out.println("结束了..");
}
public static void main(String[] args) throws Exception {
final Test sharedObject = new Test();
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
sharedObject.doSomethind();
};
}.start();
}
Thread.sleep(100);
new Thread() {
public void run() {
sharedObject.flag = true;
};
}.start();
}
}
大部分情况下线程主函数会结束并打印三个“结束了...”，因为现在的jvm其实已经实现了缓存一致性协议，也就是说当后面的线程修改了flag共享变量后，系统会尽可能将线程工作内存中的变量回刷到主存中。但这只是尽量，这就造成了某个线程会一直执行循环体，也就是你看到的打印了两个“结束了...”。
如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。一个处理器的缓存回写到内存会导致其他处理器的缓存无效，线程接下来将从主内存中读取共享变量。这样就可以保证线程能读取到其他修改的变量值。
增加volatile后效果如下：
/**
*
* @author fukailong
*
*/
public class Test {
private volatile boolean flag = false;
public void doSomethind() {
while (!flag) {
// System.out.println("执行中..");//这个位置不要打印，因为打印容易触发将线程工作内存中的变量回刷到主存中
}
System.out.println("结束了..");
}
public static void main(String[] args) throws Exception {
final Test sharedObject = new Test();
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
sharedObject.doSomethind();
};
}.start();
}
Thread.sleep(100);
new Thread() {
public void run() {
sharedObject.flag = true;
};
}.start();
}
}
二、 防止指令重排序
指令重排序是JVM为了优化指令，提高程序运行效率，在不影响单线程程序执行结果的前提下，尽可能地提高并行度。编译器、处理器也遵循这样一个目标。
在每个volatile写操作的前面插入一个StoreStore屏障。
·在每个volatile写操作的后面插入一个StoreLoad屏障。
·在每个volatile读操作的后面插入一个LoadLoad屏障。
·在每个volatile读操作的后面插入一个LoadStore屏障。
public class Singleton {
private static volatile Singleton singleton;
private Singleton() {
}
public static Singleton getsingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
以上是懒汉式单例的写法：
如果不加volatile，代码中 singleton = new Singleton()这句，这并非是一个原子操作，事实上在JVM中这句话大概做了下面3件事情
1.给singleton分配内存
2.调用Singleton的构造函数来初始化成员变量
3.将singleton对象指向分配的内存空间（执行到这一步，singleton才是非null的了）
但是在JVM的及时编译器中，存在指令重排序的优化，也就是说，第二步和第三步的顺序是无法保证的 从而导致程序出错。所以需要添加volatile来避免指令重排序。
三、 无法保证原子性
public class Test {
volatile static int a = 0;
private static CountDownLatch countDownLatch;
public static void main(String[] args) throws InterruptedException {
countDownLatch = new CountDownLatch(10000);
for (int i = 0; i < 10000; i++) {
new Thread() {
public void run() {
a++;
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(a);
}
}
代码打印的值不一定是10000，可能会是小于10000的值。
虽然变量a 设置了volatile，但是不能保证a++的操作的原子性，a++包括：读-写-改 的复合操作还是没有变化。
所以volatile不能保证原子性，但用volatile修饰long和double可以保证其操作原子性。
从Oracle Java Spec里面可以看到：
1.对于64位的long和double，如果没有被volatile修饰，那么对其操作可以不是原子的。在操作的时候，可以分成两步，每次对32位操作。
2.如果使用volatile修饰long和double，那么其读写都是原子操作
3.对于64位的引用地址的读写，都是原子操作
4.在实现JVM时，可以自由选择是否把读写long和double作为原子操作
我是double，坐标魔都，QQ群：692595133
如果读完觉得有收获的话，欢迎点赞加关注。
github博客: https://fukailong.github.io
版权归作者所有，转载请联系作者获得授权。
