volatile可见性原理最强总结

JAVA herman 56浏览
公告:“业余草”微信公众号提供免费CSDN下载服务(只下Java资源),关注业余草微信公众号,添加作者微信:xttblog,发送下载链接帮助你免费下载!
本博客日IP超过1800,PV 2600 左右,急需赞助商。
极客时间所有课程通过我的二维码购买后返现24元微信红包,请加博主新的微信号:xttblog,之前的微信号好友位已满,备注:返现
所有面试题(java、前端、数据库、springboot等)一网打尽,请关注文末小程序
视频教程免费领

最近看到一篇很好的 volatile 可见性原理总结,分享给大家!

volatile 是一种轻量且在有限的条件下线程安全技术,它保证修饰的变量的可见性和有序性,但非原子性。相对于 synchronize 高效,而常常跟 synchronize 配合使用。

volatile 原理

先简单说一下 Java 内存模型。这里主要描述的线程,工作内存,主存的变量的读写关系:

  • 主存存放线程需要操作的变量,但线程并不直接操作主存。
  • 每个线程读取主存变量都是先拷贝一份到工作内存中,不同线程工作内存互不干扰。
  • 线程修改了工作内存后,再写回主存中。
  • 每次从主存读写的过程都需要经过8原子性操作。
volatile 可见性

volatile 可见性的特殊性。

  1. 操作 use 之前必须先执行 read 和 load 操作。
  2. 操作 assign 之后必须执行 store 和 write 操作。

由特性性保证了 read、load 和 use 的操作连续性,assign、store 和 write 的操作连续性,从而达到工作内存读取前必须刷新主存最新值;工作内存写入后必须同步到主存中。读取的连续性和写入的连续性,看上去像线程直接操作了主存。

扩展:lock 和 unlock 操作并不直接开放给用户使用,而是提供给像 Synchronize 关键字指定 monitorenter 和 monitorexit 隐式使用。关于 Synchronize 的监听器锁 monitor,javac 编译后会在作用的方法前后增加 monitorenter 和 monitorexit 指令,详细的可以查看 synchronize 原理。

下面使用 Java 代码验证 volatile 可见性。

public class VolatileVisibility {
    public static class TestData {
        volatile int num = 0;
        public void updateNum(){
            num = 1;
        }
    }
    public static void main(String[] args) {
        final TestData testData = new TestData();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("ChildThread num-->"+testData.num);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                testData.updateNum();
                System.out.println("ChildThread update num-->"+testData.num);
            }
        }).start();
        while (testData.num == 0){}
        System.out.println("MainThread num-->"+testData.num);
    }
}

代码简单解释一下,分两种情况,大家可以自己改动进行测试。

  1. TestData 中的 num 如果不添加 volatile 关键字,System.out.println(“MainThread num–>”+testData.num);这一句一直不会执行。表示 while 中的条件 testData.num == 0 一直为 0,子线程修改了num 对主线程不起作用。
  2. TestData 中的 num 如果添加了 volatile 关键字,System.out.println(“MainThread num–>”+testData.num); 会执行,结果如下。
ChildThread num-->0
ChildThread update num-->1
MainThread num-->1

volatile 是非原子性的,即它不具备原子性。

  1. use 和 assign 这两个操作整体上不是一个连续性的原子操作。volatile 本身并不对数据运算处理维持原子性,强调的是读写及时影响主存。
  2. 非原子性操作举例:volatile 修饰 num,num++;num = num+1;这种就是非原子性操作。它是分步进行操作的:先主存读取 num 的值;再进行 num++ 运算;然后将 num 值写到主存。

像种操作在多线程环境中,use 和 assign 是多次出现,如果有两个线程中读取到主存的 num 都是 2,且同时执行 num++,两个线程的结果都是 3,这样就产生了脏数据,再写入主存中都是 3。核心 num++ 运算并没保证先后顺序执行。为了保证执行运算的线程顺序,可以选择 synchronize。

下面使用一段 Java 代码验证 volatile 的非原子性。

public class ValatileAtomic {
    public static class TestData {
        volatile int num = 0;
        //synchronized
        public void updateNum(){
            num++;
        }
    }
    public static void main(String[] args) {
        final TestData testData = new TestData();
        for(int i = 1; i <= 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 1; j <= 1000; j++) {
                        testData.updateNum();
                    }
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("最终结果:" + testData.num);
    }
}

按我们的意愿创建 10 个线程,每个线程累加线程累加 1000,一共是 10 * 1000 = 10000。但是 volatile int num = 0; 使用 volatile 与否都是体现非原子性,运行的结果都比 10000 小:

最终结果:9701

为了实现同步操作,在方法 updateNum() 前添加关键字 synchronize 即可,加了关键字之后,结果就符合我们的预期了。

最终结果:10000

volatile 的有序性,volatile 能够禁止指令重排。

指令重排是指:为了提高性能,编译器和和处理器通常会对指令进行指令重排序。

volatile 的有序性和禁止指令重排

上图中的三个重排位置可以调换的,根据系统优化需要进行重排。遵循的原则是单线程重排后的执行结果要与顺序执行结果相同。

内存屏障指令:volatile 在指令之间插入内存屏障,保证按照特定顺序执行和某些变量的可见性。

volatile 就是通过内存屏障通知 cpu 和编译器不做指令重排优化来维持有序性。

与 synchronize 的串行控制的区别:

  1. synchronize 无禁止指令重排。
  2. 一个变量在同一时刻只允许一条线程对其进行 lock 操作,获取对象锁,互斥排他性达到两个同步块串行执行。

volatile 的线程安全适用范围是有条件的。由于 volatile 的非原子性原因,所以它的线程安全是有条件的:

  1. 运算结果不依赖但前置,或者能保证自由一个单一线程修改变量值。
  2. 变量不需要与其他的状态变量共同参与不变的约束。 这两条件描述出自于《深入理解java虚拟机》。

volatile 与 synchronize 配合使用,先看一个 DCL(Double Check Lock) 单例代码。

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null){ // 第①处
            synchronized (Singleton.class) {
                if(instance == null){  // 第②处
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

上面的代码为什么还要使用 volatile 来修饰?

按照我们上边的写法已经对 new Singleton(); 这个操作进行了 synchronize 操作,已经保证了多线程只能串行执行这个实例化代码。事实上,synchronize 保证了线程执行实例化这段代码是串行的,但是 synchronize 并不具备禁止指令重排的特性。

而 instance = new Singleton(); 主要做了 3 件事情:

  1. java 虚拟机为对象分配一块内存 x。
  2. 在内存 x 上为对象进行初始化。
  3. 将内存 x 的地址赋值给 instance 变量。

如果编译器进行重排为:

  1. java 虚拟机为对象分配一块内存 x。
  2. 将内存 x 的地址赋值给 instance 变量。
  3. 在内存 x 上为对象进行初始化。

第一种情况,无 volatile 修饰:此时,有两个线程执行 getInstance() 方法,加入线程 A 进入代码的注释中的第②处,并执行到了重排指令的(2),与其同时线程B刚好代码注释中的第①处的 if 判断。此时,instance 有线程 A 把内存地址 x 地址赋值给了 instance,那么 instance 已经不为空只是没有初始化完成,线程 B 就返回了一个没有完成初始化的 instance,最终使用时候会出现空指针的错误。

第二种情况,有 volatile 修饰:instance 因为被 volatile 的禁止指令重排的特性,那只会安装先初始化对象再赋值给 instance 这样顺序执行,这样就能保证返回正常的实例化的对象。

最后做个总结:

  1. volatile 具有可见性和有序性,不能保证原子性。
  2. volatile 在特定情况下线程安全,比如自身不做非原子性运算。
  3. synchronize 通过获取对象锁,保证代码块串行执行,无禁止指令重排能力。
  4. DCL 单例操作需要 volatile 和 synchronize 保证线程安全。

参考资料:

业余草公众号

最后,欢迎关注我的个人微信公众号:业余草(yyucao)!可加作者微信号1:xmtxtt(5000人已满),微信号2:codedq(5000人已满),微信号3:xttblog(超2800)。备注:“xttblog”,添加博主微信拉你进微信群。备注错误不会同意好友申请。再次感谢您的关注!后续有精彩内容会第一时间发给您!原创文章投稿请发送至532009913@qq.com邮箱。商务合作也可添加作者微信进行联系!

本文原文出处:业余草: » volatile可见性原理最强总结