JUC并发编程第七篇，volatile凭什么可以保证可见性和有序性？我们该如何正确使用它？

一、volatile的作用是什么？

• 我们都知道，被 volatile 修饰的变量具有两大特点：可见性、有序性。

这里说的 可见性 和 有序性 的含义是什么呢？

• 当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中。
• 当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量。

也就是说：volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取。

二、什么是内存屏障？

• 内存屏障是一种同步屏障指令，是CPU或编译器在对内存随机访问操作中的一个同步点，目的是为了保证此点之前的所有读写操作都执行完，然后才可以开始执行此点之后的操作，避免代码重排序。

• 内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的 可见性和有序性，但volatile无法保证原子性。
  

• 内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果。

• 简单说就是：对一个 volatile 域的写, happens-before 于任意后续对这个 volatile 域的读。

三、四大内存屏障指令源码解析！

• 在 rt.jar 中有一个 Unsafe 类，如下：
  
• 它里边有三个 native 方法，继续追寻对应的C++源码如下：
  
  
• 四大屏障分别是什么意思呢？
  

四、volatile如何通过内存屏障保证可见性和有序性？

1. 保证可见性

• 保证不同线程对这个变量进行操作时的可见性，即变量一旦改变所有线程立即可见

public class VolatileSeeDemo
{
    static          boolean flag = true;       //不加volatile，没有可见性
    //static volatile boolean flag = true;       //加了volatile，保证可见性

    public static void main(String[] args)
    {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t come in");
            while (flag)
            {
            }
            System.out.println(Thread.currentThread().getName()+"\t flag被修改为false,退出.....");
        },"t1").start();

        //暂停2秒钟后让main线程修改flag值
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        flag = false;

        System.out.println("main线程修改完成");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 如果不加volatile，程序就无法停止，因为：

1.主线程修改 flag 之后没有立即刷新回主内存
2.主线程将flag刷新到了主内存，但是 t1 线程没有去获取更新。

2. 指令禁重排

• volatile的底层通过 内存屏障 禁止指令重排
  
• 当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序。
• 当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序。
• 当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。

3. 底层具体实现原理？

• 写
  

在每个 volatile 写操作的前⾯插⼊⼀个 StoreStore 屏障

在每个 volatile 写操作的后⾯插⼊⼀个 StoreLoad 屏障

• 读
  

在每个 volatile 读操作的后⾯插⼊⼀个 LoadLoad 屏障

在每个 volatile 读操作的后⾯插⼊⼀个 LoadStore 屏障

五、volatile为什么不能保证原子性？

• volatile变量的复合操作不具有原子性，比如 i++
• 原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。
• i++ 为复合操作，它分为：读取值，然后加一，最后写回三步，在这期间如果有另一个线程过来读取，就会造成线程安全问题。

volatile 不是保证可见嘛，怎么还会出现上边的问题？

• volatile 变量读写过程：

read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)

• 如上图：
• 要use(使用)一个变量的时候必需 load(载入），要载入的时候必需从主内存 read(读取）解决读的可见性。
• 写操作是把 assign 和 store 做了关联，在 assign(赋值) 后必需 store(存储)，store(存储) 后 write(写入)。
• 通过用的时候直接从主内存取，在赋值到直接写回主内存做到了内存可见性。

但是注意 蓝色的间隙，read-load-use 和 assign-store-write 是两个不可分割的原子操作，但是在 use 和 assign 之间依然有极小的一段真空期，有可能变量会被其他线程读取，丢失一次写数据。

因此volatile变量不适合参与到依赖当前值的运算，但是无论在哪一个时间点主内存的变量和任一工作内存的变量的值都是相等的，所以通常volatile用做保存某个状态的 boolean 值或 int 值。

六、如何正确的使用volatile？

• 1. 单一赋值时可以使用，复合运算赋值不可以使用

volatile int a = 10;

• 2. 一次性的状态标志时使用

volatile boolean flag = true;

• 3. 开销较低的读、写策略时使用

public class UseVolatileDemo{
    /**
     * 使用：当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销
     * 理由：利用volatile保证读取操作的可见性；利用synchronized保证复合操作的原子性
     */
    public class Counter{
        private volatile int value;

        public int getValue(){
            return value;   //利用volatile保证读取操作的可见性
        }
        public synchronized int increment(){
            return value++; //利用synchronized保证复合操作的原子性
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 4. DCL双端锁的发布

public class SafeDoubleCheckSingleton
{
    //通过volatile声明，实现线程安全的延迟初始化。
    private volatile static SafeDoubleCheckSingleton singleton;
    //私有化构造方法
    private SafeDoubleCheckSingleton(){
    }
    //双重锁设计
    public static SafeDoubleCheckSingleton getInstance(){
        if (singleton == null){
            //1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
            synchronized (SafeDoubleCheckSingleton.class){
                if (singleton == null){
                    singleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        //2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
        return singleton;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上边为双重检查锁的单例模式的写法，使用volatile禁重排，防止获取对象为空
如果不想使用 volatile，也可以使用静态内部类写法，与上边作用相同

public class SingletonDemo
{
    private SingletonDemo() { }

    private static class SingletonDemoHandler{
        private static SingletonDemo instance = new SingletonDemo();
    }

    public static SingletonDemo getInstance(){
        return SingletonDemoHandler.instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13