• 技术文章 >后端开发 >java教程

    深入理解volatile关键字

    (*-*)浩(*-*)浩2019-09-07 16:44:45转载138

    深入理解volatile关键字

    1.volatile与可见性

    都知道volatile可以保证可见性,那么到底是如何保证的呢?

    这便于Happen-before原则有关,该原则的第三条规定:对一个volatile修饰的变量,写操作要早于对这个变量的读操作。具体步骤如下:

    A线程将共享变量读进工作内存中,同时B线程也将共享变量读进工作内存中。

    在A线程对共享变量修改后,会立即刷新到主内存,此时B线程的工作内存中的共享变量就会被设置无效,需要从主内存中重新读取新值。反映到硬件上就是CPU的Cache line 置为无效状态。

    这样便保证了可见性,简单而言,就是线程在对volatile修饰的变量修改且刷新到主内存之后,会使得其它线程的工作内存中的共享变量无效,需要从主内存中再此读取。

    2.volatile与有序性

    都知道volatile可以保证有序性,那么到底是如何保证的呢?

    volatile保证有序性,比较直接,禁止JVM和处理器对volatile关键字修饰的变量进行指令重排序,但对于该变量之前或者之后的可以任意排序,只要最终的结果与没更改前的结果保持一致即可。

    底层原理

    被volatile修饰的变量在底层会加一个“lock:”的前缀,带"lock"前缀的指令相当于一个内存屏障,这恰恰是保证可见性与有序性的关键,该屏障的作用主要有一下几点:

    指令重排时,屏障前的代码不能重排到屏障后,屏障后的也不能重排到屏障前。

    执行到内存屏障时,确保前面的代码都已经执行完毕,且执行结果是对屏障后的代码可见的。

    强制将工作内存中的变量刷新到主内存。

    其它线程的工作内存的变量会设置无效,需要重现从主内存中读取。

    3.volatile与原子性

    都知道volatile不能保证原子性,那么为何不能保证原子性呢?

    代码演示:

    package com.github.excellent01;
    
    import java.util.concurrent.CountDownLatch;
    
    /**
     * @auther plg
     * @date 2019/5/19 9:37
     */
    public class TestVolatile implements Runnable {
        private volatile Integer num = 0;
        private static CountDownLatch latch = new CountDownLatch(10);
        @Override
        public void run() {
            for(int i = 0; i < 1000; i++){
                num++;
            }
            latch.countDown();
        }
    
        public Integer getNum() {
            return num;
        }
    
        public static void main(String[] args) throws InterruptedException {
            TestVolatile test = new TestVolatile();
            for(int i = 0; i < 10; i++){
                new Thread(test).start();
            }
            latch.await();
            System.out.println(test.getNum());
        }
    }

    启动10个线程,每个线程对共享变量num,加1000次,当所有的线程执行完毕之后,打印输出num 的最终结果。

    java-1.png

    很少有10000的这便是因为volatile不能保证原子性造成的。

    原因分析:

    num++的操作由三步组成:

    从主内存将num读进工作内存中

    在工作内存中进行加一

    加一完成后,写回主内存。

    虽然这三步都是原子操作,但合起来不是原子操作,每一步执行的过程中都有可能被打断。

    假设此时num的值为10,线程A将变量读进自己的工作内存中,此时发生了CPU切换,B也将num读进自己的工作内存,此时值也是10.B线程在自己的工作内存中对num的值进行修改,变成了11,但此时还没有刷新到主内存,因此A线程还不知道num的值已经发生了改变,之前所说的,对volatile变量修改后,其它线程会立即得知,前提也是要先刷新到主内存中,这时,其它线程才会将自己工作中的共享变量的值设为无效。因为没有刷新到主内存,因此A傻傻的不知道,在10的基础上加一,因此最终虽然两个线程都进行了加一操作,但最终的结果只加了一次。

    这便是为什么volatile不能保证原子性。

    volatile的使用场景

    根据volatile的特点,保证有序性,可见性,不能保证原子性,因此volatile可以用于那些不需要原子性,或者说原子性已经得到保障的场合:

    代码演示

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

    只要线程对shutdownRequested进行修改,执行work的线程会立即看到,因此会立即停止下来,如果不加volatile的话,它每次去工作内存中读取数据一直是个true,一直执行,都不知道别人已经让它停了。

    代码演示:

    package com.github.excellent;
    
    import java.util.concurrent.ThreadPoolExecutor;
    
    /**
     * 启动线程会被阻塞,flag 从内存读入,会存入寄存器中,下次直接从寄存器取值
     * 因此值一直是false
     * 即使别的线程已经将值更改了,它也不知道
     * 加volatile即可。也可以加锁,只要保证内存可见性即可
     * @auther plg
     * @date 2019/5/2 22:40
     */
    public class Testvolatile {
        public static  boolean flag = false;
        public static void main(String[] args) throws InterruptedException {
            Thread thread1 = new Thread(()->{
                for(;;) {
                    System.out.println(flag);
                }
            });
            Thread thread2 = new Thread(()->{
                for(;;){
                    flag = true;
                }
            });
            thread1.start();
            Thread.sleep(1000);
            thread2.start();
        }
    }

    执行结果:

    java-2.png

    就是这么笨,别人修改了自己不知道,还输出false。加一个volatile就ok了。

    以上就是深入理解volatile关键字的详细内容,更多请关注php中文网其它相关文章!

    phpstudy集成环境下载
    本文转载于:CSDN,如有侵犯,请联系a@php.cn删除
    专题推荐:volatile java
    上一篇:synchronized关键字的使用 下一篇:@Autowired的作用是什么?

    相关文章推荐

    • 详解volatile的使用及其原理分析• Java中关于volatile不能保证线程安全的实例• java中volatile不能保证线程安全问题的实例讲解• Java中synchronized与volatile的区别与联系

    全部评论我要评论

  • 取消发布评论发送
  • 1/1

    PHP中文网