首先我们看下Java内存模型图（假设当前有3个线程）：
参考上图，下列4条描述就能容易理解了。
- java内存模型规定了所有变量都存储在主内存中，每个线程都有自己的工作内存。
- 线程的工作内存中保存了被自身线程使用到的变量（变量都是从主内存中拷贝而来的副本）。
- 线程对变量的所有操作（读取、赋值）都必须在工作内存中进行。
- 线程间变量值的传递都需要通过主内存来完成。
Java中volatile关键字保证了可见性和一定程度上的有序性。那什么是可见性和一定程度上的有序性呢？
首先我们需要了解并发编程的三大概念：原子性、有序性、可见性。
1. 原子性：一个操作或者多个操作要么全部执行完毕并且不被干扰，要么全部都不执行。
经典例子：银行转账，A向B转账100元，包括两个操作，A减少100，B增加100。
如果不具备原子性（即两个操作都需要完成），就会出现A少了100但是B没增加100的情况。
看下面3行代码哪些是原子操作？
int i = 0; --1
i++; --2
int b = i; --3
答案只有1才是原子操作。2需要先要读取i的值，再执行i + 1操作，最后赋值给i，3需要先读取i的值，再赋值给b。
Java对基本数据类型的直接读写是原子操作，但是在32位处理器上，对long类型数据进行写操作不是原子性操作（分为2次操作：写高32位和写低32位）。创建对象也非原子操作（1.分配内存空间，2.初始化对象，3.将引用变量指向对象）。
2. 可见性：当多个线程访问同一个变量，一个线程修改了该变量的值，其他线程能够立即看到修改后的值。
Java当中提供了volatile关键字来保证可见性。
当一个共享变量被volatile修饰时，某个线程修改该变量后，会把值立即更新到主内存中，并且使其他线程中保存该变量的缓存行无效。其他线程首先从缓存行中获取该变量的值，当缓存行无效后，会去主内存中获取新值，并刷新自己的缓存行。
看个例子：
public class VolatileTest {
private volatile static int i = 0;
public void add(){
i++;
}
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
new Thread(() -> new VolatileTest().add()).start();
}
System.out.println(i);
}
}
上述代码无论怎么运行结果总会小于10000。
因为并发访问时，volatile并不保证原子性，i++分3步操作，并不是原子操作，所以线程不安全。获取想要的结果只能加锁来同步了。
3. 有序性：线程执行的顺序按照代码的先后顺序执行。
Java内存模型允许编译器和处理器对指令进行重排序，但是重排序不会影响单线程的执行结果，却会影响多线程并发执行的正确性。
重排序目的：提高并行度。
重排序时，会遵守数据依赖性。
看例子：
int i = 0;
boolean flag = false;
i = 1; //语句1
flag = true; //语句2
语句1不一定比语句2先执行，因为可能会发生指令重排序，但重排序最终一定不会影响结果。
int i = 0;
int j = 1;
i = i + 3;//语句1
j = i * i;//语句2
此时语句1一定比语句2先执行，因为反过来会影响程序结果，遵守数据依赖性。
//线程1
i = 1; //语句1
boolean flag = true; //语句2
//线程2
while(!flag){
....
}
System.out.println(i);
如果发生指令重排序，线程1中语句2先于语句1执行，线程2打印i的值可能为0（此时线程1尚未执行语句1）。
volatile能保证一定程度上的有序性，其意思是被volatile修饰过的变量代码之前的代码一定先于执行。为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器排序。请看代码示例：
int i = 0; //语句1
int b = 1;//语句2
volatile int x = 233; // 语句3
int m = 1;//语句4
int n = 2;//语句5
volatile能保证语句1和2先于语句3执行，但不保证语句1和2的先后顺序。同样，语句3会先于语句4和5执行，但不保证语句4和5的先后顺序。
另外Java具有先天的有序性，也被称为happens-before 原则（先行发生原则），这里只说一个特别有用的原则（其他就不说了，说了也记不住）。
volatile变量规则：对一个volatile域的写happens-before任意后续对该volatile域的的读。ReentrantLock锁就是使用volatile变量来表示同步状态的。（看ReentrantLock源码时，懂这条规则就很受用。）
volatile关键字使用的场景
当对成员变量只进行读写操作时，volatile可以保证线程安全，此时无需synchronized。
改进单例模式的懒汉式：
public class Singleton {
private Singleton() {
}
//注意 volatile
private static volatile Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
当我们new一个对象的时候，实际上分3个步骤：
- 在堆内存中为对象分配一块内存
- 调用对象的构造函数初始化
- 将对象实例instance指向对象，即：将对象内存地址赋值给instance
如果不加volatile关键字，代码进行指令重排序，new对象的步骤顺序可能是1→3→2。并发时，其他线程获取到的对象可能是未执行步骤2的对象，因为执行1和3后，instance != null。
关于单例模式的懒汉式，更推荐静态内部类的写法：
public class Singleton {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.singleton;
}
private static class SingletonHolder{
static Singleton singleton = new Singleton();
}
}
每个类都有一个唯一的初始化锁，静态内部类只有在被访问的时候才会初始化，而且只会初始化一次。
再看一个线程等待唤醒机制的例子，先用同步锁：
/**
* 子线程执行100次，主线程执行10次，如此循环50次
*/
public class ThreadTest {
public static void main(String[] args) {
new ThreadTest().init();
}
public void init() {
Task task = new Task();
new Thread(() -> {
for (int i = 0; i < 50; i++) {
task.son();
}
}).start();
int a = 0;
Runnable r = () -> System.out.println(a);
for (int i = 0; i < 50; i++) {
task.main();
}
}
class Task {
private boolean flag = true;
public synchronized void main() {
while (flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "main: " + i);
}
flag = true;
this.notify();
}
public synchronized void son() {
while (!flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "son: " + i);
}
flag = false;
this.notify();
}
}
}
而如果用volatile关键字，会简单许多：
public class VolatileTest {
public static void main(String[] args) {
new VolatileTest().init();
}
public void init() {
InnerTask task = new InnerTask();
new Thread(() -> {
for (int i = 0; i < 50; i++) {
task.son();
}
}).start();
for (int i = 0; i < 50; i++) {
task.main();
}
}
class InnerTask {
private volatile boolean flag = true;
public void main() {
while (flag) {
}
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " main: " + i);
}
flag = true;
}
public void son() {
while (!flag) {
}
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " son: " + i);
}
flag = false;
}
}
}