volatile简介

volatile关键字用来修饰成员变量，用来保证并发环境下共享变量的可见性。那可见性是什么？简单来说，可见性指的是当一个线程修改了共享变量，其他所有线程能够读到该变量修改后的值。有些地方会将volatile称为"轻量级synchronized"，但是和synchronized相比，volatile无法保证操作的原子性，所以使用volatile是无法保障线程安全。除了可见性之外，volatile还有一个功能就是防止指令的重排序。

先来看个不可见的例子（该例子在不同环境效果不一定相同）

public class VisibilityTest {
    public static void main(String[] args) throws Exception {
        VisibilityThread v = new VisibilityThread();
        v.start();

        Thread.sleep(1000);//停顿1秒等待新启线程执行
        System.out.println("即将置stop值为true");
        v.stopIt();
        Thread.sleep(1000);
        System.out.println("finish main");
        System.out.println("main中通过getStop获取的stop值:" + v.getStop());
    }
}
class VisibilityThread extends Thread {
    private boolean stop;

    public void run() {
        int i = 0;
        System.out.println("start loop.");
        while(!getStop()) {
            i++;
            //System.out.println(i++);
        }
        System.out.println("finish loop,i=" + i);
    }

    public void stopIt() {
        stop = true;
    }

    public boolean getStop(){
        return stop;
    }
}

例子中main线程已经将stop的值修改为true，但是VisibilitiyThread没有读取到修改后的值，所以while循环将会一致运行。如果想要让stop修改的值能被VisibilitityThread线程读到，只需将stop变量声明为volatile即可。

再来看个volatile无法保证线程安全的例子

public class VolatileUnsafeExample {
    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final VolatileExample test = new VolatileExample();
        for (int i = 0; i < 10; i++) {
            new Thread() {
                public void run() {
                    for (int j = 0; j < 1000; j++)
                        test.increase();
                }
            }.start();
        }
        while(Thread.activeCount()>2) {  //保证前面的线程都执行完，在Idea中这里要设置2
            System.out.println("--------------");
            Thread.yield();
        }
        System.out.println(test.inc);
    }
}

上面的例子理论上输出inc的值应该为10000，但是实际运行多次的结果都会是小于10000的值。说明volatile无法保证线程安全。

Java内存模型

Java内存模型(即Java Memory Model，简称JMM)，可用下图描述JMM: java内存模型

本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。
一个共享变量在多个CPU（一个CPU可以看成一个线程）中都存在缓存，那么就可能存在缓存不一致的问题。如何解决这个问题呢？可以通过缓存一致性协议解决这个问题。
缓存一致性的思想是，当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

volatile使用优化

说volatile的优化之前，我们先来看看操作系统中的缓存模型，示意图如下 操作系统的缓存模型

cache line:缓存行，缓存中最小的存储单元。在不同的机器上，缓存行大小有所不同，通常为64位。

根据上面的图所示，如果X和Y逻辑上没有任何关系，但物理上却被分到同一个缓存行中，每一个线程竞争获取到缓存行的读写权限，才能对缓存行进行读写。加入线程2在CPU核心2上获得了对缓存行进行读写的权限，那么线程1必须刷新它的缓存后才能在核心1上获得读写权限，这导致这个缓存行在不同的线程间多次通过L3缓存来交换最新的拷贝数据，这极大的影响了多核心CPU的性能。这就是伪共享问题。
我们可以通过填充变量的字节长度，使其刚好等于一个缓存行的长度，这样就能很好的避免伪共享带来的性能问题。
在JDK1.7中，LinkedTransferQueue类就是通过让volatile变量填充字节，使得其长度刚好等于缓存行的大小，从而提升出队入队的效率。具体请看源码。