volatile关键字理解

volatile是Java提供的轻量级的同步机制，主要有三个特性：

保证内存可见性

不保证原子性

禁止指令重排序

1.1 保证内存可见性

当某个线程在自己的工作内存中将主内存中共享数据的副本修改并刷新到主内存后，其它线程能够立即感知到该共享数据发生变化：

/**
 * Volatile关键字：【内存可见性】
 * - 使用语句（1），注释语句（2） -> 程序一直等待
 * - 使用语句（2），注释语句（1） -> 程序正常结束
 *
 * @author sherman
 */
public class VolatileMemoryVisibility {
    //private int i;            // （1）
    private volatile int i;     // （2）

    public void changeI() {
        this.i = 100;
    }

    public static void main(String[] args) {
        VolatileMemoryVisibility vd = new VolatileMemoryVisibility();
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            vd.changeI();
            System.out.println("子线程改变了i的值！");
        }).start();

        while (vd.i == 0) {
        }
        System.out.println("main线程感知到i的变化!");
    }
}

1.2 不保证原子性

不保证原子性正是volatile轻量级的体现，多个线程对volatile修饰的变量进行操作时，会出现容易出现写覆盖的情况（i++）：

/**
 * Volatile关键字：【内存可见性】
 * - 使用语句（1），注释语句（2） -> 程序一直等待
 * - 使用语句（2），注释语句（1） -> 程序正常结束
 *
 * @author sherman
 */
public class VolatileMemoryVisibility {
    //private int i;            // （1）
    private volatile int i;     // （2）

    public void changeI() {
        this.i = 100;
    }

    public static void main(String[] args) {
        VolatileMemoryVisibility vd = new VolatileMemoryVisibility();
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            vd.changeI();
            System.out.println("子线程改变了i的值！");
        }).start();

        while (vd.i == 0) {
        }
        System.out.println("main线程感知到i的变化!");
    }
}

1.3 禁止指令重排序

计算机执行程序为了提高性能，编译器和处理器常常会进行指令重排。源代码 -> 编译器优化重排 -> 指令并行重排 -> 内存系统重排 -> 最终执行指令。单线程环境下程序最终执行结果和执行顺序结果一致，多线程环境下线程交替执行，由于编译器优化重排的存在，两个线程使用的变量一致性无法保证。处理器在进行指令重排的时候必须考虑指令之间的数据依赖性。volatile能够实现禁止指令重排的底层原理：

内存屏障（Memory Barrier）：它是一个CPU指令。由于编译器和CPU都能够执行指令重排，如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，任何指令都不能和该条Memory Barrier指令进行重排序，即通过插入内存屏障指令能够禁止在内存屏障前后的指令执行重排序优化。
内存屏障的另外一个作用是强制刷新各种CPU的缓存数据，因此任何CPU上的线程都能够读取到这些数据的最新版本。以上两点正好对应了volatile关键字的禁止指令重排序和内存可见性的特点。
对volatile变量进行写操作时，会在写操作之后加入一条store屏障指令，将工作内存中的共享变量copy刷新回主内存中；对volatile变量进行读操作时，会在读操作之前加入一条load的屏障指令，从主内存中读取共享变量。

/**
 * Volatile关键字：【禁止指令重排序】
 * 高并发环境下DCL（Double Check Lock）单例模式使用volatile防止指令重排序
 *
 * @author sherman
 */
public class VolatileForbidRearrange {
    /**
     * 对INSTANCE使用volatile可以防止下面3条语句发生指令重排变成:1 -> 3 -> 2
     * 多线程环境下：当发生指令重排时, 进行到第3条语句时, INSTANCE != null但是该内存仅仅是原始内存
     * 对象并没有在该原始内存上初始化, 该方法直接return INSTANCE导致当前线程拿到一个非null但是未初始化
     * 的对象。如果在该内存上进行相应的访问对象数据操作就会出错
     */
    private static volatile VolatileForbidRearrange INSTANCE = null;

    private VolatileForbidRearrange() {
    }

    public static VolatileForbidRearrange getInstance() {

        if (INSTANCE == null) {
            synchronized (VolatileForbidRearrange.class) {
                if (INSTANCE == null) {
                    // 以下语句实际等同于3条语句：
                    // 1. rawMemory = memoryAllocate();     // 开辟原始内存
                    // 2. instance(rawMemory);              // 在原始内存上对对象初始化
                    // 3. 将rawMemory的地址赋值给INSTANCE, 此时INSTANCE != null
                    INSTANCE = new VolatileForbidRearrange();
                }
            }
        }
        return INSTANCE;
    }
}

1.4 volatile使用场景

高并发环境下DCL单例模式使用volatile，见上面示例
JUC包下AtomicXxx类：原子类AtomicXxx中都有一个成员变量value，该value变量被声明为volatile，保证AtomicXxx类的内存可见性，而原子性由CAS算法&Unsafe类保证，结合这两点才能让AtomicXxx类很好地替代synchronized
关键字。

public class AtomicInteger extends Number implements java.io.Serializable {
    // ...
    private volatile int value;
    // ...
}