Volatile保证内存可见性和防止指令重排

一、 Volatlile 如何保证内存可见性?

内存可见性：多个线程操作同一个变量，可确保写线程更新变量，其他读线程可以读取该变量的最新值。

1. 内存可见性

线程在操作主存(堆栈内存)数据时，会将数据从主内存copy一个副本到线程私有栈(工作内存)中。

JMM两条规定：

1. 线程对共享变量的操作必须在线程私有工作内存中进行，不能直接从主存中读写
2. 不同线程之间无法直接访问其他线程的私有工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

要实现共享变量的内存可见性，必须保证两点：

1. 线程修改共享变量后，能够及时将数据同步到主存
2. 其他线程能够及时从主存中读取变更后的数据到自己的工作内存中

在java中，共享变量内存可见性的实现有两种：synchronized和volatile

导致共享变量内存不可见的原因：

1. 线程交叉执行
2. 重排序结合的线程交叉执行
3. 共享变量的变更没有及时在主存和其他线程的工作内存中得到同步

2. Volatile应用场景

观察以下代码：

public class T01Volatile {
    private static boolean bool = true;
    public static void main(String[] args) {
        T01Volatile demo = new T01Volatile();
        new Thread(()->{
        while (bool){
                System.out.println(1);
            }
    },"A").start();
    Thread.sleep(100);
        bool = false;
    }
}

这段代码很平常，控制台并不会有任何输出 ，因为A线程还没来得及执行，bool就被设置为false,add方法很快就执行完毕。
一旦如上代码运行在-server服务器模式64bit的jvm上，就会出现死循环。
这是因为： 在JVM被设置为-server模式时，为了提高线程运行效率，线程A每次while循环都会从私有栈(虚拟机栈)中取值，而不是去方法区取static boolean bool的值。

• 我们来复习下jvm的知识：
• 
• 如上图，静态变量private static boolean bool被装载到了方法区，是为共享数据，被所有线程共享。而线程A执行add方法是在线程私有栈虚拟机栈中进行的，bool的数据会被cpu复制到缓存区，在-server模式下，A线程并不会每次去方法区取bool值与栈数据保持同步，而是每次仅从栈中取值，这使得尽管方法区bool的值已设置为false,A线程私有栈并不会更新这个值。 此时就需要在静态变量bool前加volatile修饰。

Volatile会强制每次都从公共堆栈(本案例是方法区)取值，而不是从线程私有栈中取值。

3. Volatile并不支持原子操作

Volatile本身并不处理数据的原子性，而是强制对数据的读写影响到主内存。

public class VolatileTest {
    private volatile static int count = 0;
    private void countPlus() throws InterruptedException {
        Thread.sleep(500);
        String s = Thread.currentThread().getName() + ":  count1 == " + count;
        count++;
        s+="  count2 = "+count;
        System.out.println(s);
    }
    public static void main(String[] args) {
        VolatileTest demo = new VolatileTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {demo.countPlus();}, "线程" + i).start();
        }
    }
}
//以下为控制台输出结果
线程3:  count1 == 0  count2 = 2
线程4:  count1 == 0  count2 = 1
线程9:  count1 == 7  count2 = 8
线程8:  count1 == 5  count2 = 7
线程7:  count1 == 5  count2 = 6
线程2:  count1 == 0  count2 = 1
线程1:  count1 == 4  count2 = 5
线程5:  count1 == 2  count2 = 3
线程6:  count1 == 3  count2 = 4
线程0:  count1 == 0  count2 = 1

观察如上代码，我们会发现几个问题：

1. count2为什么存在多个1？

答：三个线程同时读到count=0,并将count++等于1write到主存

1. count2=9和10为什么不存在?

答：如1, 因并发问题，三个线程的同时将0累加到1，故有两个线程的累加无效。

1. 线程3执行count++之后，为什么count被加了两次?

答：在上述代码中，count被读出

3. i++ 非线程安全

• 既然volatile每次读写都是直接从共享内存取值 ，为什么还是无法做到数据安全？
• 
• 如上图2-2 原来即使count被volatile修饰，线程仍然不会直接去方法区操作count,而是先将count从方法区copy一个副本到栈内存，然后对副本做++的计算操作，执行完毕再将值改写方法区变量count.
• 其详细过程如下：

1. read 从方法区读取静态变量count=0
2. load copy静态变量count副本到私有栈
3. use 执行count++计算操作，此时操作的count是栈中副本
4. asign 将1赋值给count
5. store
6. write 将1写入到方法区count变量中
7. 综上，对于Volatile修饰的变量，JVM只能保证从主内存加载到线程私有内存的值是最新的。如上234步骤的操作却是非原子性的，在此期间，其他线程仍然可以修改count值，使得线程脏读。

这也就是说：volatile关键字仅解决变量读取时的可见性，并无法保证原子性。

本文核心理论依据《java多线程编辑艺术》
_

二、 Volatile如何防止指令重排

• 双重检查锁中的指令重排问题
• cpu缓存和jvm