• volatile


    volatile是轻量级的synchronized,如果volatile变量修饰符使用恰当,它比synchronized的使用和执行成本更低,因为它不会引起线程上下文的切换(线程间的保存到再加载)和调度。

    内存可见性
    多线程操作的时候,一个线程修改了一个变量的值 ,其他线程能立即看到修改后的值。
    防止重排序
    即程序的执行顺序按照代码的顺序执行(处理器为了提高代码的执行效率可能会对代码进行重排序)。

    可见性:当一个线程修改一个共享变量时,另外一个线程能读到这个修改后的值。

    volatilte是如何保证可见性?

    在x86处理器下通过工具获取JIT编译器生成的汇编指令来看看对Volatile进行写操作CPU会做什么事情。

    有volatile变量修饰的共享变量进行写操作的时候会多出第二行汇编代码。

    Lock前缀的指令在多核处理器下会引发两件事:

    1)将当前处理器缓存行的数据写回系统内存
    2)这个写回内存的操作会使得其他CPU里缓存了该内存地址的数据无效

    如果对声明了volatile的变量进行写操作,JVM就会向处理器发送一条lock前缀的指令,将这个变量所在缓存行的数据写回到系统内存。每个处理器通过嗅探在总线上传播的数据来检查自己缓存值是不是过期,当处理器发现自己缓存行对应的内存地址被修改,就会将当前处理器的缓存行设置成无效状态,当处理器对这个数据进行修改操作的时候,会重新从系统内存中把数据读到处理器缓存里。

     volatile的使用

    1、防止重排序:

     我们从一个最经典的例子来分析重排序问题。大家应该都很熟悉单例模式的实现,而在并发环境下的单例实现方式,我们通常可以采用双重检查加锁(DCL)的方式来实现。其源码如下:

    package com.paddx.test.concurrent;
    
    public class Singleton {
        public static volatile Singleton singleton;
    
        /**
         * 构造函数私有,禁止外部实例化
         */
        private Singleton() {};
    
        public static Singleton getInstance() {
            if (singleton == null) {
                synchronized (singleton) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

    现在我们分析一下为什么要在变量singleton之间加上volatile关键字。要理解这个问题,先要了解对象的构造过程,实例化一个对象其实可以分为三个步骤:

      (1)分配内存空间。

      (2)初始化对象。

      (3)将内存空间的地址赋值给对应的引用。

    但是由于操作系统可以对指令进行重排序,所以上面的过程也可能会变成如下过程:

      (1)分配内存空间。

      (2)将内存空间的地址赋值给对应的引用。

      (3)初始化对象

      如果是这个流程,多线程环境下就可能将一个未初始化的对象引用暴露出来,从而导致不可预料的结果。因此,为了防止这个过程的重排序,我们需要将变量设置为volatile类型的变量。

    2、实现可见性

    可见性问题主要指一个线程修改了共享变量值,而另一个线程却看不到。引起可见性问题的主要原因是每个线程拥有自己的一个高速缓存区——线程工作内存。volatile关键字能有效的解决这个问题,我们看下下面的例子,就可以知道其作用:

    package com.paddx.test.concurrent;
    
    public class VolatileTest {
        int a = 1;
        int b = 2;
    
        public void change(){
            a = 3;
            b = a;
        }
    
        public void print(){
            System.out.println("b="+b+";a="+a);
        }
    
        public static void main(String[] args) {
            while (true){
                final VolatileTest test = new VolatileTest();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        test.change();
                    }
                }).start();
    
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        test.print();
                    }
                }).start();
    
            }
        }
    }

    直观上说,这段代码的结果只可能有两种:b=3;a=3 或 b=2;a=1。不过运行上面的代码(可能时间上要长一点),你会发现除了上两种结果之外,还出现了第三种结果:b=3;a=1

    为什么会出现b=3;a=1这种结果呢?正常情况下,如果先执行change方法,再执行print方法,输出结果应该为b=3;a=3。相反,如果先执行的print方法,再执行change方法,结果应该是 b=2;a=1。那b=3;a=1的结果是怎么出来的?原因就是第一个线程将值a=3修改后,但是对第二个线程是不可见的,所以才出现这一结果。如果将a和b都改成volatile类型的变量再执行,则再也不会出现b=3;a=1的结果了。

     

  • 相关阅读:
    C# 杂项
    C# 数组
    我的博客第一天
    Java使用多线程异步执行批量更新操作
    Python爬取百度图片
    以友盟+U-Push为例,深度解读消息推送的筛选架构解决方案应用与实践
    python自动化办公之爬取HTML图片写入PPT实战
    理解Python闭包,这应该是最好的例子
    爬取b站《守护解放西》弹幕
    爬取b站《守护解放西》弹幕
  • 原文地址:https://www.cnblogs.com/dingpeng9055/p/11194462.html
Copyright © 2020-2023  润新知