Volatile笔记

什么是volatile?

1、volatile 类型修饰符。使用如下：

 volatile int i;

2、volatile是多线程的一种解决方案，使用volatile定义的变量，多线程可见。

volatile 特点：

1：可见性。
2：禁止重排序。

实现原理

1：可见性

线程本身并不直接与主内存进行数据的交互，而是通过线程的工作内存来完成相应的操作。如下图所示

这也是导致线程间数据不可见的本质原因。因此要实现volatile变量的可见性，直接从这方面入手即可。对volatile变量的写操作与普通变量的主要区别有两点：
　　（1）修改volatile变量时会强制将修改后的值刷新的主内存中。
　　（2）修改volatile变量后会导致其他线程工作内存中对应的变量值失效。再读取该变量值的时候就需要重新从读取主内存中的值。
　　如下图所示。

2：禁止重排序

什么是重排序？为了性能优化，JVM在不改变正确语义的前提下，会允许编译器和处理器对指令序列进行重排序。参考-指令重排序
那怎么才能防止指令重排序呢？内存屏障。
JMM内存屏障分为四类见下图，
java编译器会在生成指令系列时在适当的位置会插入内存屏障指令来禁止特定类型的处理器重排序。为了实现volatile的内存语义，JMM会限制特定类型的编译器和处理器重排序，JMM会针对编译器制定volatile重排序规则表：

"NO"表示禁止重排序。为了实现volatile内存语义时，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。对于编译器来说，发现一个最优布置来最小化插入屏障的总数几乎是不可能的，为此，JMM 采取了保守策略：

1. 在每个volatile写操作的前面插入一个StoreStore屏障；
2. 在每个volatile写操作的后面插入一个StoreLoad屏障；
3. 在每个volatile读操作的后面插入一个LoadLoad屏障；
4. 在每个volatile读操作的后面插入一个LoadStore屏障。
   需要注意的是：volatile写是在前面和后面分别插入内存屏障，而volatile读操作是在后面插入两个内存屏障
   StoreStore屏障：禁止上面的普通写和下面的volatile写重排序；
   StoreLoad屏障：防止上面的volatile写与下面可能有的volatile读/写重排序
   LoadLoad屏障：禁止下面所有的普通读操作和上面的volatile读重排序
   LoadStore屏障：禁止下面所有的普通写操作和上面的volatile读重排序
   下面以两个示意图进行理解，图片摘自相当好的一本书《java并发编程的艺术》。

多线程可见性测试

代码如下：

public class VolatileDemo {

    //private static boolean isOver = false;  不用volatile
    private static volatile boolean isOver = false;  //使用volatile
    
    public static void main(String[] args) {
        //线程A
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!isOver) 
            }
        },"A");
        thread.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        isOver = true;
    }
}

不用 volatile时，isOver一直是false,即便后面改成true，循环依赖没有停止。

使用 volatile时，线程A能识别到 isOver的改变，并重新加载值，循环停止。

多线程原子性测试

public class VolatileTest01 {
    volatile int i;

    public void addI(){
        //i++;
        i=i+1;
    }

    public static void main(String[] args) throws InterruptedException {
        final  VolatileTest01 test01 = new VolatileTest01();
        for (int n = 0; n < 1000; n++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    test01.addI();
                }
            }).start();
        }
        Thread.sleep(2000);//等待2秒，保证上面程序执行完成
        System.out.println(test01.i);
    }
}

得出结果：

929

PS：重复试，没有一次结果是对的。

测试结论：

volatile 能保证多线程的可见性，防止数据脏读。却不能保证原子性。

volatile 应用场景

根据volatile,可见性，非原子性的特点，可以用于以下场景

1：状态标志

也许实现 volatile 变量的规范使用仅仅是使用一个布尔状态标志，用于指示发生了一个重要的一次性事件，例如完成初始化或请求停机。

volatile boolean shutdownRequested;
......
public void shutdown() { shutdownRequested = true; }
public void doWork() { 
    while (!shutdownRequested) { 
        // do stuff
    }
}

2： 一次性安全发布（one-time safe publication）

缺乏同步会导致无法实现可见性，这使得确定何时写入对象引用而不是原始值变得更加困难。在缺乏同步的情况下，可能会遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在。（这就是造成著名的双重检查锁定（double-checked-locking）问题的根源，其中对象引用在没有同步的情况下进行读操作，产生的问题是您可能会看到一个更新的引用，但是仍然会通过该引用看到不完全构造的对象）。

public class BackgroundFloobleLoader {
    public volatile Flooble theFlooble;
 
    public void initInBackground() {
        // do lots of stuff
        theFlooble = new Flooble();  // this is the only write to theFlooble
    }
}
 
public class SomeOtherClass {
    public void doWork() {
        while (true) { 
            // do some stuff...
            // use the Flooble, but only if it is ready
            if (floobleLoader.theFlooble != null) 
                doSomething(floobleLoader.theFlooble);
        }
    }
}

3：独立观察（independent observation）

安全使用 volatile 的另一种简单模式是定期 发布 观察结果供程序内部使用。例如，假设有一种环境传感器能够感觉环境温度。一个后台线程可能会每隔几秒读取一次该传感器，并更新包含当前文档的 volatile 变量。然后，其他线程可以读取这个变量，从而随时能够看到最新的温度值。

public class UserManager {
    public volatile String lastUser;
 
    public boolean authenticate(String user, String password) {
        boolean valid = passwordIsValid(user, password);
        if (valid) {
            User u = new User();
            activeUsers.add(u);
            lastUser = user;
        }
        return valid;
    }
}

4：双重检查（double-checked）

单例模式的一种实现方式，但很多人会忽略 volatile 关键字，因为没有该关键字，程序也可以很好的运行，只不过代码的稳定性总不是 100%，说不定在未来的某个时刻，隐藏的 bug 就出来了。

class Singleton {
    private volatile static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            syschronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    } 
}

本人能力有限，如有错误请指出。
参考
https://www.jianshu.com/p/157279e6efdb
https://blog.csdn.net/devotion987/article/details/68486942