Java基础-并发编程-volatile关键字使用与原理分析

Java工程师知识树 / Java基础

---

volatile的使用

volatile用于保证不同的线程共享一个变量时每次都能获取最新的值。

volatile 具有锁的部分功能并且性能比锁更好，所以也被称为轻量级锁。

不加锁时,出现死锁现象:

package com.thread.study;

public class VisibilityTest {

    private boolean flag = true; // 不使用volatile 之前

    public void refresh() {
        flag = false;
        System.out.println(Thread.currentThread().getName().concat("修改flag"));
    }

    public void load() {
        System.out.println(Thread.currentThread().getName().concat("开始执行"));
        int i = 0;
        while (flag) {
            i ++;
        }
        System.out.println(Thread.currentThread().getName().concat("跳出循环了，此时i = ").concat(String.valueOf(i)));
    }

    public static void main(String[] args) {
        VisibilityTest test = new VisibilityTest();
        new Thread(test::load,"加载数据线程：").start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(test::refresh,"刷新标识线程：").start();
    }

}

执行结果：出现死锁 ,如下图所示

使用volatile修饰变量后执行结果:

加载数据线程：开始执行
刷新标识线程：修改flag
加载数据线程：跳出循环了，此时i = 1363490114

volatile关键字针对其修饰的变量作用

1. 保证多线程中的共享变量是始终可见的。(但不保证volatile引用对象内部的属性是完全可见的)。(保障变量线程间可见性)
2. 防止相关代码的重排序，从指令级别达到了轻量级锁的目的。(保障相关代码执行的有序性)
3. 对于volatile修饰的变量必须一次性赋值。(保障对其修饰的变量本身的原子性)

volatile的应用场景

正确的使用场景，基本符合一个原则：一写多读：有一个数据，只由一个线程更新，其他线程都来读取。

比如，有一个系统回调，告诉我们最新的设备的经纬度，而其他的线程需要去用这个经纬度做一些计算，那么这个经纬度就一直被第一个线程写，其他线程就只负责读取。此时，经纬度就很适合用volatile修饰，这样可以保证其他线程永远读取到的是最新的数值。

比如，单例模式。

volatile 实现原理

可见性

使用 volatile 修饰共享变量后，每个线程要操作变量时会从主内存中将变量拷贝到本地内存作为副本，当线程操作变量副本并写回主内存后，会通过CPU 总线嗅探机制 告知其他线程该变量副本已经失效，需要重新从主内存中读取。

嗅探机制工作原理：每个处理器通过监听在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从主内存中把数据读到处理器缓存中。

注意：基于 CPU 缓存一致性协议，JVM 实现了 volatile 的可见性，但由于总线嗅探机制，会不断的监听总线，如果大量使用 volatile 会引起总线风暴。所以，volatile 的使用要适合具体场景。

有序性

为了实现 volatile 内存语义（即内存可见性），JMM 会限制特定类型的编译器和处理器重排序。

重排序规则表

使用 volatile 修饰变量时，根据 volatile 重排序规则表，Java 编译器在生成字节码时，会在指令序列中插入内存屏障指令来禁止特定类型的处理器重排序。

内存屏障是一组处理器指令，它的作用是禁止指令重排序和解决内存可见性的问题。底层使用汇编语言lock addl $0x0,(%rsp)命令实现。

在JMM中，内存屏障的插入策略如下：

• 在每个volatile写操作的前面插入一个StoreStore屏障
• 在每个volatile写操作的后面插入一个StoreLoad屏障
• 在每个volatile读操作的前面插入一个LoadLoad屏障
• 在每个volatile读操作的后面插入一个LoadStore屏障

StoreStore屏障可以保证在volatile写之前，前面所有的普通读写操作同步到主内存中
StoreLoad屏障可以保证防止前面的volatile写和后面有可能出现的volatile度/写进行重排序
LoadLoad屏障可以保证防止下面的普通读操作和上面的volatile读进行重排序
LoadStore屏障可以保存防止下面的普通写操作和上面的volatile读进行重排序
上面的内存屏障策略可以保证任何程序都能得到正确的volatile内存语义。

内存屏障的插入策略

总结：编译器不会对 volatile 读与 volatile 读后面的任意内存操作重排序；编译器不会对 volatile 写与 volatile 写前面的任意内存操作重排序。

原子性

示例：

package com.thread.study;

public class TicketWindow implements Runnable {

    public static volatile int TICKET_NUM = 10; // 以为关键字volatile后，这段程序就是线程安全的，可是事实并不是如此

    @Override
    public void run() {
        while (true) {
            if (TICKET_NUM > 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖了票号为" + TICKET_NUM-- + "的票");
            } else {
                return;
            }
        }
    }

    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow();
        Thread t1 = new Thread(ticketWindow, "1号售票窗口");
        Thread t2 = new Thread(ticketWindow, "2号售票窗口");
        Thread t3 = new Thread(ticketWindow, "3号售票窗口");
        t1.start();
        t2.start();
        t3.start();

    }
}
//打印结果
1号售票窗口卖了票号为10的票
3号售票窗口卖了票号为9的票
2号售票窗口卖了票号为8的票
1号售票窗口卖了票号为7的票
3号售票窗口卖了票号为6的票
2号售票窗口卖了票号为6的票
1号售票窗口卖了票号为5的票
2号售票窗口卖了票号为4的票
3号售票窗口卖了票号为4的票
1号售票窗口卖了票号为3的票
2号售票窗口卖了票号为2的票
3号售票窗口卖了票号为2的票
1号售票窗口卖了票号为1的票
3号售票窗口卖了票号为0的票
2号售票窗口卖了票号为-1的票

分析：TICKET_NUM--其实是一个复合操作，包括三步骤： （1）读取TICKET_NUM的值。（2）对TICKET_NUM减1。 （3）将TICKET_NUM的值写回内存。 volatile是无法保证这三个操作是具有原子性的。

volatile 可以使纯赋值操作是原子的，如 boolean flag = true; falg = false。但是对 ++,--等字节指令为多个的操作不能保证原子性。所以，对于volatile修饰的变量必须一次性赋值。

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

修改volatile变量分为四步：

• 1）读取volatile变量到本地内存
• 2）修改变量值
• 3）本地内存值写回
• 4）插入内存屏障，即lock指令，让其他线程可见
  前三步都是不安全的，取值和写回之间，不能保证没有其他线程修改。volatile修饰变量原子性需要锁来保证。