深入理解Java虚拟机（六）volatile关键字

关键字volatile是JVM提供的最轻量级的同步机制，但是他不容易被正确理解和使用。JVM内存模型对volatile转么定义了一些特殊的访问规则。
一旦一个共享变量被volatile修饰之后，那么它就具有了两层含义：

• 保证此变量对所有线程的可见性： “可见性” 指的是：当一条线程修改了这个变量的值，新值对于其他线程来说可以立即得知的。
• 禁止进行指令重排序

volatile的可见性

  我们可以知道在这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说可以立即得知的。普通变量是做不到这一点的，普通变量在线程间传递均需要通过主内存来实现。例如：线程A修改了一个普通变量的值，然后向内存进行写回；另一条线程B在线程A写回完成之后再从主内存进行读取操作，新值才会对线程B可见。
  关于volatile的可见性作用，被volatile修饰的变量对所有线程总是立即可见的，对于volatile修饰的变量的所有写操作总是能被所有线程知道，但是对于volatile变量运算操作在多线程环境中并不保证安全。

public class Main {
    // 1. volatile修饰的变量是多线程可见的。
    // 2. volatile修饰的变量进行运算，不保证原子性。
    public static volatile int num = 0;
    // num自增加
    public static void increase() {
        num++;
        // num = num + 1;
    }
    //////////////////////////////////////////
    //////////////////////////////////////////
    //////////////////////////////////////////
    //测试代码    
    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        // 10个线程，每个线程中increase()方法跑十次
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(num);
    }
}

上面的代码所示，num变量的任何改变都会立即反应到其他线程中，但是存在多条线程同时调用increase()方法时，就会出现线程安全问题。因为num++操作并不具备原子性，它等同于num = num + 1，volatile关键字保证了num的值在取值时是正确的，但是在执行num+1的时候，其他线程可能把num值增大了，这样在+1后悔吧较小的数组同步回主内存之中。
上述代码结果如下：

我们可以发现上述代码运行出现了997这个错误的值，这就出现了多线程安全失败的问题，那么如果我们想要让这段代码安全，应该如何解决呢？
 由于volatile关键字只保证可见性，在不符合以下两条规则的运算场景中，我们仍然需要通过加锁（synchronized或者lock）来保证原子性。

public class Main {
    // 1. volatile修饰的变量是多线程可见的。
    // 2. volatile修饰的变量进行运算，不保证原子性。
    public static volatile int num = 0;
    // num自增加
    public synchronized static void increase() {
        num++;
        // num = num + 1;
    }
}

1. 运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值
2. 变量不需要与其他的状态变量共同参与不变约束

如下代码这类场景就特别适合使用volatile来控制并发，当close()方法被调用时，能保证所有线程中执行的doWork()方法都立即停止下来。

	volatile boolean close;
    public void close(){
        close=true;
    }
    public void doWork(){
        while (!close){
            System.out.println(Thread.currentThread().getName() + "safe....");
        }
    }

对于boolean变量close值的修改属于原子性操作，因此可以通过使用volatile修改变量close，使用该变量对其他线程立即可见，从而达到线程安全的目的。那么JMM是如何实现让volatile变量对其他线程立即可见的呢？
  实际上，当写一个volatile变量时，JMM会把该线程对应的工作内存中的共享变量值刷新到主内存中，当读取一个volatile变量时，JMM会把该线程对应的工作内存置为无效，那么该线程将只能从主内存中重新读取共享变量。volatile变量正是通过这种写-读方式实现对其他线程可见。

volatile禁止重排优化

volatile关键字另一个作用就是禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。普通变量仅仅会保证在该方法的执行过程中所以来赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序和程序代码中执行的顺序一致。
volatile关键字禁止指令重排序有两层含义：

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是可见的。
举例：指令重排序

Map configOptions;
char[] configText;
volatile boolean initialized = false;


//假设以下代码在线程A执行
//模拟读取配置文件信息，当读取完成后将initialized设置为true以通知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText,configOptions);
initialized = true;


//假设以下代码在线程B执行
//等待initialized为true，代表线程A已经把配置信息初始化完成
while(!initialized) {
    sleep();
}
//使用线程A初始化好的配置信息
doSomethingWithConfig();

单例模式中的Double Check

双重检索锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查instance == null，一次实在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的if，如果在同步块内不进行二次检验的话就会生成多个实例了。

// 单例
class Singleton{
 
    private static Singleton instance = null;

    private Singleton() {
    }
    public static Singleton getInstance() {
    	// 第一次检查
        if(instance==null) {
        	// 同步块
            synchronized (Singleton.class) {
                if(instance==null){
                	// 此处在多线程环境会出现问题
                	instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

上面的代码看起来很完美，也有双重检查，但是它是有问题的，它在单线程环境下并没有什么问题，但如果在多线程环境下会出现线程安全问题。原因在于某一个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化。因为instance = new Singleton();不是一个原子操作，这句话在JVM中做了下面3件事情：

memory = allocate();	// 1.给instance对象分配内存空间
instance(memory);		// 2.调用Singleton的构造函数来初始化成员变量
instance = memory;		// 3.将instance对象执行分配的内存空间，此时instance != null

但是在JVM的即时编译器中存在指令重排序的优化，也就是说上面的第二步和第三步的顺序是不能保证的，所以最终的执行顺序可能时1-2-3，但也有可能时1-3-2。如果是后者，则在3执行完毕、2未执行之前，被其他线程抢占了，这是instance已经是非null了（但却没有初始化），所以其他线程就会直接返回instance，然后使用，就会报错。那么如何解决这个问题呢，我们就只需要将instance变量声明成volatile，禁止指令重排序就行了。
正确的单例模式的书写：

// 单例
class Singleton{
    //  私有的，volatile，static
    private volatile static Singleton instance = null;
    // 私有的
    private Singleton() {
    }
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}