Java内存模型是围绕着原子性，有序性，可见性展开的。

• volatile 能保证数据的可见性
• volatile 能保证一定的有序性
• volatile 不能保证操作的原子性。

1. volatile 关键字的语义

用 volatile 关键字修饰一个共享变量（类的成员变量，类的静态成员变量）后，有两个作用：

1. 保证了不同线程对于这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这个新值对于其他线程来说是立即可见的。
2. 禁止进行指令重排序。

volatile 修饰的变量进行写操作是以Lock前缀的汇编指令实现的，才指令在多核处理器下引发一下两件事：

1. 将当前处理器缓存行的数据写会到系统内存
2. 这个写会内存的操作会使其他CPU缓存了该内存地址的数据无效。

2. volatile 不保证原子性

• 任意单个volatile变量的读/写具有原子性，但是类似于++这种复合操作不具有原子性
• Java内存模型的原子性可以由synchronized和Lock实现。

例如，下面的代码结果应该是100000，但是与运行结果一般会小于100000：

public class VolatileTest {
    static volatile long i = 0;

    public static class PlusTask implements Runnable {
        @Override
        public void run() {
            for (int k = 0; k < 10000; k++) {
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(new PlusTask());
            threads[i].start();
        }
        for (int i = 0; i < 10; i++) {
            threads[i].join();
        }
        System.out.println(i);
    }
}

3. volatile能保证一定的有序性

volatile关键字能够禁止指令重排序，因此能在一定程度上保证有序性：

1. 在对指令进行优化时，不能将volatile变量访问的语句放在后面执行，也不能把volatile变量后面的语句放到前面执行。
2. 当程序指定到volatile变量的读写操作时，在其前面的操作的更改肯定已经完成，且结果对后面的操作可见，在起后面的操作肯定没有进行。
   例如：

// x,y为非volatile变量
// flag为volatile变量

x = 2;        //语句1
y = 0;        //语句2
flag = true;  //语句3
x = 4;         //语句4
y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。

但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。这就是能保证“一定”的有序性的原因。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

4. volatile原理

• 通过在指令序列中插入内存屏障实现来禁止指定类型的处理器重排序