volatile关键字解析

volatile 保证此变量对所有线程的可见性。

这个可见性是指，当一个线程读取volatile修饰的变量时，永远读取的都是最后一个线程写回主内存的最新值。某个线程在读取数据之后，另一个线程对变量值做了修改，这个线程是不知道的，这就导致当前线程读取的值是过期的，当前线程将过期的数据经过计算写回主内存时，就会出现问题。看下面代码：

public class VolatileTest {
    public static volatile int race = 0;

    /**
     * 每次都对race累加
     */
    public static void increase() {
        race++;
    }

    private static int THREAD_COUNT = 20;

    public static void main(String[] args) {
        // start 20 thread, every thread invoke increase function 20 times
        for (int tCount = 0; tCount < THREAD_COUNT; tCount++) {
            new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    increase();
                }
                System.out.println(Thread.currentThread().getName() + "is finished");
            }).start();
        }

        /**
         * 当还存在线程运行时，不结束主线程。
         */
        while (Thread.activeCount() > 1) {
            System.out.println("main thread yield, the active count is " + Thread.activeCount());
            Thread.yield();
        }
        // in theory, the result is 20 * 10000 = 200000
        System.out.println(race);
    }
}

看结果，race变量的值基本上不会是20000。
javap -verbose 类文件， 查看方法的字节码片段
给出方法编译的字节码

  public static void increase();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field race:I
         3: iconst_1
         4: iadd
         5: putstatic     #2                  // Field race:I
         8: return
      LineNumberTable:
        line 14: 0
        line 15: 8

字节码还是变成了几个命令行，假如当前线程执行了getstatic时volatile修饰的变量是正确的，当在执行iconst_1和iadd时，其他线程可能将主内存中的race值加大了，当前线程将变量写回主内存时，就会覆盖之前的值，导致race的值一直累加不到20000。
通过以上分析，发现如果需要保证方法的原子性还是需要使用synchronized或者java.util.concurrent中的原子类。

volatile 的第二个作用是禁止指令重排优化。

先看一段代码：

  public class Singleton {
      private Singleton() {}
      private volatile static Singleton instance;

      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }

          return instance;
      }
  }

上述代码是基于双锁检测实现的单例模式。对比instance添加volatile修饰符前后汇编代码：
添加volatile之前，

添加volatile之后，

发现添加volatile修饰符后，汇编多生成了一条

0x0000000002b83350: lock add dword ptr [rsp],0h

add dword ptr [rsp],0h，意思是将双字节的栈指针寄存器加0，这句代码没有问题，关键是其前面的修饰符lock。lock的作用使得本CPU的Cache写入内存，该写入动作也会引起其他CPU或者核无效化，这样就保证了本次值的修改对其他CPU可见了。

lock是如何禁止指令重排的呢？指令重排是指CPU允许多条执行不按程序规定顺序执行。但如果指令之间如果有依赖，那么指令就不能重排。例如一个指令，给地址A加1，另一个指令为将地址A的数据乘以2，还有另一条指令是将B地址的数据加5。可以看出指令1和指令2之间是有依赖关系的，不能重排，但是对于指令3 将B地址的数据加5，和指令1和指令2没有依赖关系的，所以可以重排，而且重排完成后依然是有序的。当使用lock指令，将计算的数据更新到主内存后，意味着所有之前的操作都已经执行完成，这样便形成了“指令重排无法越过的内存屏障”。