volatile关键字在JAVA中的特性

关键字volatile是JVM提供的最轻量级的同步机制，JVM内存模型对volatile专门定义了一些特殊的访问规则。

当变量被volatile关键字修饰后它在Java中具有以下两种特性：

1.保证此变量对所有线程的可见性

这里的"可见性"解释为 : 当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。普通变量做不到这一点，普通变量的值在线程间传递均需要通过主内存来完成。
volatile关键字只保证可见性，当其参与运算在并发下一样是不安全的，Java里面的运算并非原子操作，此时会出现并发修改问题。

例如下面代码：

public class Main {
  public static volatile int num = 0;
        public static void increase() {
            num++;
        }
        public static void main(String[] args) {
            Thread[] threads = new Thread[10];
            for (int i = 0; i < 10; i++) {
                threads[i] = new Thread(new Runnable() {
                    @Override
                     public void  run() {
                        try{Thread.sleep(1000);
                        }catch(InterruptedException e){
                            e.printStackTrace();
                        }
                            increase();

                    }
                });
                threads[i].start();
            }
            while (Thread.activeCount() > 2) {
                Thread.yield();
            }
            System.out.println(num);
        }
}

问题会出现并发修改错误，解释就在于num++之中，实际上num++等同于num = num+1。volatile关键字保证了num的值在取值时是正确的，但是在执行num+1的时候，其他线程可能已经把num值增大了即并发修改，这样在+1后会把较小的数值同步回主内存之中。此时只要再run方法前加上synchronized关键字即可。

总结：在不符合以下两条规则的运算场景中，我们仍然需要通过加锁(synchronized或
者lock)来保证原子性。
（1）运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值；
（2）变量不需要与其他的状态变量共同参与不变约束，即变量独立，不参与其它线程的运算；

2.禁止指令重排序

通常，编译器和处理器为了提高程序的运行性能，对指令进行重新排序。普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序和程序代码中执行的顺序一致，这样就可能会对程序产生副作用。

禁止指令重排可以理解为以下两个层面：

（1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

（2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把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是可见的。

下面以懒汉单例设计模式（Double Check）为例讲解以下指令重排带来的副作用。

观察下面代码：

class Singleton2{
    //2.产生唯一的一个对象
    private static  Singleton2  singleton;
    //1.构造方法私有化
    //限制在外部产生对象的方法
    private Singleton2(){
    };
    public static Singleton2 getInstance(){
        if(singleton==null){
            singleton=new Singleton2();
        }
        return singleton;
    }
}

问题主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：
（1）给 instance 分配内存 ；
（2）调用 Singleton 的构造函数来初始化成员变量；
（3） 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了） ；

但是在 JVM 的即时编译器中存在指令重排序的优化，即上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是1-3-2，则在 3 执行完毕、2 未执行之前，当前线程被线程二抢占了，这时 instance 已经是非 null 了（但
却没有初始化），所以线程二会直接返回 instance并使用，然后程序就会报错。 改进办法只需要将 instance 变量声明成 volatile 就可以了。

算法改进：

class Singleton2{
    //2.产生唯一的一个对象
    private   volatile static  Singleton2  singleton;
    //1.构造方法私有化
    //限制在外部产生对象的方法
    private Singleton2(){
    };
    public static Singleton2 getInstance(){
        if(singleton==null){
            singleton=new Singleton2();
        }
        return singleton;
    }
}