对volatile关键字的学习总结

在并发编程中，有如下三大特性：

• 可见性：当一条线程修改了变量的值，新值对于其他线程来说是可以立即得知的；
• 有序性：JVM执行代码的顺序跟程序员编写代码的顺序一致；
• 原子性：不可被拆分的操作，例如赋值语句：int i = 1;

对于volatile修饰的变量，我们常说其具有可见性和有序性。在这篇文章中，先抛开这些概念，用代码先简单地对比下，对用volatile修饰和未用volatile修饰的变量进行操作有什么区别

1、对变量只进行读操作

public class VolatileReadTest {
    public static final int COUNT = 10000000;
    public static volatile int volatileValue = 0 ;
    public static int normalValue = 0 ;

    public static void main(String[] args) {
        readVolatileValue();
        readNormalValue();
    }

    /**
     * 对使用volatile关键字修饰的变量进行COUNT次读操作
     */
    public static void readVolatileValue() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < COUNT; i++) {
            int temp = volatileValue;
        }
        System.out.println("readVolatileValue : " + (System.currentTimeMillis() - start));
    }

    /**
     * 对未使用volatile关键字修饰的变量进行COUNT次读操作
     */
    public static void readNormalValue() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < COUNT; i++) {
            int temp = normalValue;
        }
        System.out.println("readNormalValue : " + (System.currentTimeMillis() - start));
    }
}

在这段代码中，分别定义了两个变量：一个用volatile修饰、一个未用volatile修饰，然后在for循环中进行同样次数的读取该变量的操作，耗时时间如下：

readVolatileValue : 3ms
readNormalValue : 3ms

可以看出时间相同（就算不相等，差距也很小），所以说只对变量做读操作，volatile相对于普通变量不会做任何特殊的处理。它们访问该变量的逻辑都是：CPU始终都会从Cache中获取该变量，第一次会发生Cache Miss，这时Cache就会从主内存将变量加载进来，后面CPU就能Cache Hit。

2、对变量进行读写操作

public class VolatileReadAndWriteTest {
    public static final int COUNT = 10000000;
    public static volatile int volatileSum = 0 ;
    public static int normalSum = 0 ;

    public static void main(String[] args) {
        readAndWriteVolatileValue();
        readAndWriteNormalValue();
    }

    /**
     * 对使用volatile关键字修饰的变量进行COUNT次读写操作
     */
    public static void readAndWriteVolatileValue() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < COUNT; i++) {
            volatileSum++;
        }
        System.out.println("readAndWriteVolatileValue : " + (System.currentTimeMillis() - start) + "ms");
    }

    /**
     * 对未使用volatile关键字修饰的变量进行COUNT次读写操作
     */
    public static void readAndWriteNormalValue() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < COUNT; i++) {
            normalSum++;
        }
        System.out.println("readAndWriteNormalValue : " + (System.currentTimeMillis() - start) + "ms");
    }
}

在这段代码中，与前面代码唯一不同的是，不光对变量进行了读，还进行了写，耗时时间如下：

readAndWriteVolatileValue : 85ms
readAndWriteNormalValue : 4ms

可以看出它们的差距还是很大的，而且该差距跟COUNT的变大成正比。造成这种现象的原因是：在对变量进行写操作时，首先也还是从主内存加载到Cache，再送往CPU进行了递增操作，最后将修改后的值返回到Cache。接下来是关键，用volatile修饰的变量，同时会将修改后的值同步到主内存，而普通变量则不会。正是多次从Cache到主内存的时间，造成了该时间差。

之所以对用volatile修饰的变量进行了写操作后，其值会同步到主内存，就是为了要保证可见性。下面我们再通过一段代码，观察下volatile在多线程中是如何保证可见性的。

3、可见性

public class VolatileVisibilityTest {
    public static boolean initFlag = false;

    public static void main(String[] args) throws Exception {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("waiting data...");
                while (!initFlag) {
                }
                System.out.println("success");
            }
        },"A").start();
        Thread.sleep(100);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("prepareing data...");
                initFlag = true;
                System.out.println("prepare end");
            }
        },"B").start();
    }
}

首先不使用volatile，定义一个变量initFlag=false，在线程A中判断如果该值变为true，就会打印后面的"success"，在线程B中将initFlag置为true。理想情况下，我们希望会打印出"success"，可实际上打印结果如下：

waiting data...
prepareing data...
prepare end

造成这种现象的原因，是由于线程A和B在使用initFlag时首先会将该false值从主内存分别拷贝到它们的工作内存中，在B中进行了initFlag = true操作后，会将最新值同步到主内存；但是A始终会从其工作内存中读取，读到的始终是false，因此不会执行后面的代码。
现在对initFlag变量进行volatile修饰：
public static volatile boolean initFlag = false;
再次观察打印结果

waiting data...
prepareing data...
prepare end
success

可以看出能正常打印success，这是由于对initFlag进行volatile修饰，在线程B中执行initFlag=true后，在Java内存模型中：
1、B首先发送一个lock指令，将主内存中的initFlag所在的地址加锁。当执行完store和write操作后进行解锁；
2、B将修改后变量的值通过总线更新到主内存时，会发送一个该变量失效的广播。A一直在对总线进行嗅探，当接收到该广播后，将自身工作内存中的该变量置为无效;
3、当A从工作内存中读取该变量时，发现已置为无效，就会从主内存中重新读取；
之所以在将新值通过总线同步到主内存之前有个加锁的操作，因为不加锁可能会出现这种问题：在B执行store和write前，A可能会读取主内存中的值，但这时的值还没有更新过来。

4、i++操作

首先声明，volatile无法保证原子性，如下代码进行验证

public class VolatileAtomicityTest {
    public static final int COUNT = 10000;
    public static volatile int sum = 0;

    public static void increase() {
        sum = sum + 1;
    }

    public static void main(String[] args) throws Exception {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(sum);

    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < COUNT; i++) {
                increase();
            }
        }
    }
}

定义一个静态变量sum，新建两个线程，分别进行COUNT次递增操作，实际打印出的结果并不是我们预期的20000，而是小于20000。这是因为sum = sum + 1;不是原子操作，它可以拆分为如下三个原子操作：
1、从主内存将sum的值加载到工作内存，read和load；
2、CPU从工作内存读取该值，use；
3、CPU执行完加1操作后将值更新到工作内存，assign；
问题就出在2和3之间，用volatile修饰的sum，虽然use时能保证工作内存中的值是最新的，但是在assign时别的线程可能修改了最新值并同步到了工作内存，那么此时use的值就过期了，导致某些加1操作的效果丢失。

备注：如下图是CPU访问内存中变量的过程