java volatitle介绍与使用

关于关键字volatile可以说是Java虚拟机提供的轻量级的同步机制，但是它并不容易完全被正常、完整地理解，以至于许多程序员都不习惯去使用它，遇到需要处理多线程数据竞争问题的时候一律使用Synchronized来进行同步。了解volatile变量的语义对了解多线程操作的其他特性很有意义。

当一个变量定义为volatile后，它将具备两种特性，第一是保证此变量对所有线程的可见性，这里的”可见性“是指当一条线程修改了这个变量的值，新值对于其它线程来说是可以立即得知的。而普通变量是做不到这一点，普通变量的值在线程间传递均需要通过主内存来完成，例如，线程A修改一个普通变量的值，然后向主内存进行回写，另外一条线程B在线程A回完成了之后再从主内存进行读取操作，新变量值才会对线程B可见。

特性一：可见性

介绍到这里可能很多朋友会说，并发线程吗我把变量声明称volatile就可以了嘛，哪里有那么复杂，事实并非如此，看段代码：

import java.util.concurrent.*;

/**
 * by lv xiao long
 */
public class App {
    public static volatile int count;

    public static void increase() {
        ++count;
    }

    private static final int THREADS_COUNT = 10;

    private static CountDownLatch countDownLatch=new CountDownLatch(10);

    public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        // 启动10条线程，每条线程连续自增1000次。最后count等于10*1000对吗？
        for (int index = 0; index < THREADS_COUNT; index++) {
            Runnable run = new Runnable() {
                public void run() {
                    for (int i=0;i<1000;i++){
                        increase();
                    }
                    countDownLatch.countDown();
                }
            };
            exec.execute(run);
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //等待所有线程结束
        exec.shutdown();
        System.out.print(count);
    }
}

　　最后结果你会看到不是10*1000，按道理来说在线程中使用volatile变量，每次使用之前都要先刷新，执行引擎看不到不一致情况 ，因此不存在一致性问题，但是在java里面运算并非原子操作，导致volatitle变量的运算在并发下一样是不安全的。

由于volatitle变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁（使用synchronized或java.util.conrueent中的原子类）来保证原子性。

规则1：运行结果并不依赖变量当前值，或者能够确保只有单一线程修改变量的值。

规则2：变量不需要与其他的状态变量共同参与不变约束。

例如下面场景：

volatile boolean off;

public void shutdown(){
      off=true;
}

public void doWork(){

    while(!off){
        //do stuff
    }
}

特性二：禁止指令重排序优化

普通的变更仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，这也就是java 内存模型中描述的所谓的”线程内表现为串行的语义“

Map configOptions;

char[] configText;

//此变量必须定义为volatile
volatile boolean initialized = false;

//假设以下代码在线程A中执行
configOptions=new HashMap();

configText=readConfigFile(fileName);

processConfigOptions(configText,configOptions);

initialized =true;

//假设以下代码在线程B中执行
while(!initialized ){

      sleep();  

}
doSomethingWithConfig();

上面代码定义initialized 变量时没有使用volatile修饰，就可能会由于指令重排序优化，导致位于线程A中最后一句代码”initialized =true“提前被执行，得不到最终你想要的结果。

如果在面试过程中，遇到有关volatile相关的话题，可以简明扼要的说明volatile两种特性，以及适用的一些场景，个人觉得一般都能通过。