volatile的原理和使用场景

上下文切换
CPU为每个线程分配时间片（几十ms），CPU不断切换线程执行，切换的时候会记录状态，保证能够从原来的状态继续执行。当然上下文切换是有开销的，当线程执行时间非常短时我们用并发可能会耗时更久。使用【Lmbench3】和【vmstat】可以测量上下文切换的时间和次数。
为了降低开销我们应减少上下文切换，多线程竞争锁会引起上线文切换，CAS算法无需加锁，可以减少上线文切换，使用最少线程（任务少，线程多，大量线程会waiting）
先说下在多线程环境线程可见性问题在操作系统底层的提现
计算机在运行程序时，每条指令都是在CPU中执行的，在执行过程中势必会涉及到数据的读写。我们知道程序运行的数据是存储在主存中，这时就会有一个问题，读写主存中的数据没有CPU中执行指令的速度快，如果任何的交互都需要与主存打交道则会大大影响效率，所以就有了CPU高速缓存。CPU高速缓存为某个CPU独有，只与在该CPU运行的线程有关。
有了CPU高速缓存虽然解决了效率问题，但是它会带来一个新的问题：数据一致性。在程序运行中，会将运行所需要的数据复制一份到CPU高速缓存中，在进行运算时CPU不再也主存打交道，而是直接从高速缓存中读写数据，只有当运行结束后才会将数据刷新到主存中。举一个简单的例子：

i++

当线程运行这段代码时，首先会从主存中读取i( i = 1)，然后复制一份到CPU高速缓存中，然后CPU执行 + 1 （2）的操作，然后将数据（2）写入到告诉缓存中，最后刷新到主存中。其实这样做在单线程中是没有问题的，有问题的是在多线程中。如下：
假如有两个线程A、B都执行这个操作（i++），按照我们正常的逻辑思维主存中的i值应该=3，但事实是这样么？分析如下：
两个线程从主存中读取i的值（1）到各自的高速缓存中，然后线程A执行+1操作并将结果写入高速缓存中，最后写入主存中，此时主存i==2,线程B做同样的操作，主存中的i仍然=2。所以最终结果为2并不是3。这种现象就是缓存一致性问题。
解决缓存一致性方案有两种：
1）通过在总线加LOCK#锁的方式
2）通过缓存一致性协议
但是方案1存在一个问题，它是采用一种独占的方式来实现的，即总线加LOCK#锁的话，只能有一个CPU能够运行，其他CPU都得阻塞，效率较为低下。
第二种方案，缓存一致性协议（MESI协议）它确保每个缓存中使用的共享变量的副本是一致的。其核心思想如下：当某个CPU在写数据时，如果发现操作的变量是共享变量，则会通知其他CPU告知该变量的缓存行是无效的，因此其他CPU在读取该变量时，发现其无效会重新从主存中加载数据。因此volatile并不能保证线程安全。
volatile使用场景举例：
1、多线程调度环境下，修饰调度标识

Logger log = Logger.getLogger(Volatile.class);

    class Timer extends Thread{

        private volatile boolean isWorking = false;

        public void startWork(){
            this.isWorking = true;
        }

        public void end(){
            this.isWorking = false;
        }

        public void work(){
            if(this.isWorking){
                log.info("start to work...");
            }
        }

    }

2、单例模式（double-check）

static class Singleton {

        private volatile static Singleton instance;

        private Singleton(){}

        public static Singleton getInstance(){
            // first check
            if(instance == null){
                synchronized(Singleton.class){
                    // second check
                    if(instance == null){
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }

    }

如果不用volatile修饰，可能会返回一个未完全初始化的示例
如果不使用volatile：线程1进入getInstance方法 ==> instance == null,线程1进入synchronized块 ==> 线程1开始执行 new Singleton();但是在执行构造函数之前使instance != null ==> 线程2检查instance是否为null，此时 != null，线程2将instance返回，此时instance构造完整但是初始化的一部分
3、读写锁（读操作大于写操作）

class Counter{
        private volatile int value;

        public int getValue(){
            return value;
        }

        public synchronized int increment(){
            return value++;
        }
    }

使用synchronized确保增量操作是原子性的，并使用volatile保证当前结果线程可见性。