精华内容
下载资源
问答
  • java volatile 关键字详解

    千次阅读 热门讨论 2021-04-03 15:30:49
    java volatile 关键字详解 一,什么是volatile关键字,作用是什么 ​ volatilejava虚拟机提供的轻量级同步机制 ​ 作用是: 1.保证可见性 2.禁止指令重排 3.不保证原子性 本篇具体就讲解 什么叫保证了可见性, 什么叫...

    java volatile 关键字详解

    一,什么是volatile关键字,作用是什么

    ​ volatile是java虚拟机提供的轻量级同步机制

    ​ 作用是: 1.保证可见性 2.禁止指令重排 3.不保证原子性

    本篇具体就讲解 什么叫保证了可见性, 什么叫禁止指令重排,什么是原子性

    而在这之前需要对JMM 有所了解

    二,什么是JMM

    ​ JMM(java 内存模型 Java Memory Model 简称JMM) 本身是一个抽象的概念,并不在内存中真实存在的,它描述的是一组规范或者规则,通过这组规范定义了程序中各个变量(实例字段,静态字段和构成数组对象的元素)的访问方式.

    JMM的同步规定:

    ​ 1.线程解锁之前,必须把共享变量刷新回主存

    ​ 2.线程加锁锁之前,必须读取主存的最新值到自己的工作空间

    ​ 3.加锁解锁必须是 同一把锁

    ​ 由于 JMM运行程序的实体是线程.而每个线程创建时JMM都会为其创建一个自己的工作内存(栈空间),工作内存是每个线程的私有 数据区域.而java内存模型中规定所有的变量都存储在主内存中,主内存是共享内存区域,所有线程都可以访问,但线程的变量的操作(读取赋值等)必须在自己的工作内存中去进行,首先要 将变量从主存拷贝到自己的工作内存中,然后对变量进行操作,操作完成后再将变量操作完后的新值写回主内存,不能直接操作主内存的变量,各个线程的工作内存中存储着主内存的变量拷贝的副本,因IC不同的线程间无法访问对方的工作内存,线程间的通信必须在主内存来完成, 其简要访问过程如下图:

    在这里插入图片描述

    三,可见性

    ​ 可见性:指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。

    ​ 通过前面的 JMM介绍,我们知道各个线程对主内存的变量的操作都是各个线程各自拷贝到自己的工作内存中进行操作,然后在写回主内存中

    ​ 这就可能存在一个线程a修改了共享变量X的值但还未写回主内存,又有一个线程b对共享变量X进行操作,但 此时线程a的工作内存的共享变量X对线程吧来说是不可见的,这种工作内存与主内存同步延迟的问题就造成了可见性问题

    四,不保证原子性

    ​ 原子性:某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败

        class MyData{volatile int number = 0;
    ​    Object object = new Object();
    
        public void addTo60(){
            this.number = 60;
        }
        
        public void addPlusPlus(){
            this.number++;
        }
        
        AtomicInteger atomicInteger = new AtomicInteger();
        
        public void addAtomic(){
            atomicInteger.getAndIncrement();
        }
    }
    
    /**
     * 验证volatile的可见性
    
     * 1.当number未被volatile修饰时,new Thread将number值改为60,但main线程并不知道,会一直在循环中出不来
    
     * 2.当number使用volatile修饰,new Thread改变number值后,会通知main线程主内存的值已被修改,结束任务。体现了可见性
     *
    
     * 验证volatile不保证原子性
    
     * 1.原子性是指,某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败
     *
    
     * 如何解决呢?
    
     * 1.使用synchronize
    
     * 2.使用AtomicInteger
     *
     */
    public class VolatileDemo {
        public static void main(String[] args) {
            //seeByVolatile();
            atomic();
        }
        //验证原子性
        public static void atomic() {
            MyData myData = new MyData();
            for (int i = 1; i <= 20; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 1; j <= 1000; j++) {
                            /*synchronized (myData.object){
                                myData.addPlusPlus();
                            }*/
                            myData.addPlusPlus();
                            myData.addAtomic();
                        }
                    }
                }).start();
            }
    
            //等待上面20个线程全部计算结束
            while (Thread.activeCount() > 2){
                Thread.yield();
            }
            
            System.out.println(Thread.currentThread().getName() + "int finally number is " + myData.number);
            System.out.println(Thread.currentThread().getName() + "AtomicInteger finally number is " + myData.atomicInteger);
        }
    
        //验证可见性的方法
        public static void seeByVolatile() {
            MyData myData = new MyData();
            //第一个线程
            new Thread(){
                public void run(){
                    System.out.println(Thread.currentThread().getName() + " come in");
                    try {
                        sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    myData.addTo60();
                    System.out.println(Thread.currentThread().getName() + " update number to " + myData.number);
                }
            }.start();
    
            //第二个线程 main
            while (myData.number == 0){
            
            }
            System.out.println(Thread.currentThread().getName() + "mission is over");
        }
    }
    

    number++在多线程下是非线程安全,不是原子性操作?

    在这里插入图片描述

    五,禁止指令重排

    ​ 计算机在执行程序时,为了提高性能,编译器和处理 器常常会对指令做重排,一般分为一下三种:

    在这里插入图片描述

    单线程的环境里指令重排确保最终执行的结果和代码顺序执行的结果一致

    处理器在进行指令重排是必须 要考虑指令之间的数据依赖性

    多线程的环境交替执行,由于编译器优化重排的存在,俩个线程使用变量能否保证一致性是无法确定的,无法预料的

    实例一:

    在这里插入图片描述

    实例二:

    在这里插入图片描述

    线程操作资源类,线程1访问method1,线程2访问method2,正常情况顺序执行,a=6
    多线程下假设出现了指令重排,语句2在语句1之前,当执行完flag=true后,另一个线程马上执行method2,a=5

    所以volatile 禁止指令重排,从而避免多线程的 环境下出现执行乱序 的情况

    六:使用volatile 的经典案例

     单例DCL的代码
    
    public class SingletonDemo {
        private static SingletonDemo instance = null;
    
        private SingletonDemo(){
            System.out.println(Thread.currentThread().getName() + "构造方法");
        }
        
        //DCL双端加锁机制
        public static SingletonDemo getInstance(){
            if (instance == null){
                synchronized (SingletonDemo.class){
                    if (instance == null){
                        instance = new SingletonDemo();
                    }
                }
            }
            return instance;
        }
    }
    

    这种写法在多线程条件下可能正确率为99.999999%,但可能由于指令重排出错

    原因在于某一个线程执行到第一次检测,读取到instance不为null,instance引用对象可能还没有完成初始化.

    instance = new SingletonDemo();; 分为一下三步

    1. memory = allocate() //分配内存
    2. ctorInstanc(memory) //初始化对象
    3. instance = memory //设置instance指向刚分配的地址

    2 ,3 步不存在数据依赖, 可以指令重排的执行顺序为 1 ,3 ,2,设置instance指向刚分配的地址,次数instance还没有初始化完

    但此时instance不为null了,若正好此时有一个线程来访问,就出现了线程安全问题

    所以需要添加volatile 关键字

    public class SingletonDemo {
        private static volatile SingletonDemo instance = null;
    
        private SingletonDemo(){
            System.out.println(Thread.currentThread().getName() + "构造方法");
        }
        //DCL双端加锁机制
        public static SingletonDemo getInstance(){
            if (instance == null){
                synchronized (SingletonDemo.class){
                    if (instance == null){
                        instance = new SingletonDemo();
                    }
                }
            }
            return instance;
        }
    }
    
    展开全文
  • Java volatile的性能分析

    2021-03-19 14:57:36
    volatile通过内存屏障来实现禁止重排序,通过Lock执行来实现线程可见性,如果我们的程序中需要让其他线程及时的对我们的更改可见可以使用volatile关键字来修饰,比如AQS中的state 所以在一个线程写,多个线程读的...

    volatile通过内存屏障来实现禁止重排序,通过Lock执行来实现线程可见性,如果我们的程序中需要让其他线程及时的对我们的更改可见可以使用volatile关键字来修饰,比如AQS中的state

    所以在一个线程写,多个线程读的情况下,或者是对volatile修饰的变量进行原子操作时,是可以实现共享变量的同步的,但是i++ 不行,因为i++ 又三个操作组成,先读出值,然后再对值进行+1 ,接着讲结果写入,这个过程,如果中间有其他线程对该变量进行了修改,那么这个值就无法得到正确的结果。

    今天我们讨论的重点不是他的功能,而是他的性能问题,首先我们可以看下我们对非volatile变量进行操作,循环+1,多个线程操作多个变量(这里不存在并发,至于为什么要多个线程跑,后面就知道了)

    首先定义一个Data,内容是四个long类型的变量,我们将会使用四个线程分别对他们进行递增计算操作:

    class Data {
    	public  long value1 ;
        public  long value2;
        public  long value3;
        public  long value4;
    }

    运行类:

    public class SyncTest extends Thread{
        public static void main(String args[]) throws InterruptedException{
            Data data = new Data();
            ExecutorService es = Executors.newFixedThreadPool(4);
            long start = System.currentTimeMillis();
            int loopcont = 1000000000;
            Thread t[] = new Thread[4];
            t[0] = new Thread(()-> {
                for(int i=0;i<loopcont;i++){
                    data.value1 = data.value1+i;
                }
            } );
            t[1] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value2 = data.value2+i;
                }
            } );
            t[2] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value3 = data.value3+i;
                }
            } );
            t[3] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value4 = data.value4+i;
                }
            } );
            for(Thread item:t){
                es.submit(item);
            }
            for(Thread item:t){
                item.join();
            }
            es.shutdown();
            es.awaitTermination(9999999, TimeUnit.SECONDS);
            long end = System.currentTimeMillis();
            System.out.println(end-start);  
        }
        
    }

    这样的结果是:608ms

    接着我们用volatile修饰long:

    class Data {
    	public volatile long value1 ;
        public volatile long value2;
        public volatile long value3;
        public volatile long value4;
    }

    运行结果为:66274

    可以看出是100倍左右,使用volatile的性能为什么会这么差呢,原因是因为,因为volatile的读和写都是要经过主存的,读会废弃高速缓存的地址,从缓存读,写也会及时刷新到主存

    那么我们用一个线程操作一个变量试试呢:结果是:5362

    是要好很多,为什么多线程情况下差距这么大呢,我们并没有进行并发操作,并没有锁,那是因为发生了伪共享,CPU的高速缓存的最小单位是缓存行,一般是64 byte,这个CPU核心私有的,当我们的cpu核心1 跑线程0 , 核心2跑线程1的时候,因为局部性原理,core1的L1缓存将value1加载到缓存,也会将后面的几个一并加载进来,core2也一样,也就是说,core1和core2的缓存差不多都把四个值保存了,而缓存行中如果一个值发生变化,cpu会吧整个缓存行重新加载,那么可以理解下,因为内存的一致性,就会导致各个核心不停的从主存加载和刷新,这就导致了性能的问题。

     

    怎么解决呢:

    1.将值拷贝至线程内部操作,完成后进行赋值操作,也就是Data中的值依然使用volatile修饰,线程的执行逻辑改为:

    t[0] = new Thread(()-> {
            	long value = data.value1 ;
                for(int i=0;i<loopcont;i++){
                	value ++ ;
                }
                data.value1 = value ;
            } );
            t[1] = new Thread( () -> {
            	long value = data.value1 ;
                for(int i=0;i<loopcont;i++){
                    value++;
                }
                data.value2 = value ;
            } );
            t[2] = new Thread( () -> {
            	long value = data.value1 ;
                for(int i=0;i<loopcont;i++){
                	value ++;
                }
                data.value3 = value ;
            } );
            t[3] = new Thread( () -> {
            	long value = data.value1 ;
                for(int i=0;i<loopcont;i++){
                	value ++;
                }
                data.value4 = value ;
            } );

    这个结果是多少呢:76ms,可以看到这个比不用volatile修饰还要快很多,那是因为线程私有的可以直接在线程内部栈内存操作,时间就是cpu消耗的时间,并不会发生内存耗时

     

    2使用缓存行填充

    这里我们把Data里面的long修饰一下:

    public class VolatileLongPadding {
        public volatile long p1, p2, p3, p4, p5, p6; // 注释  
    }
     
    package com.demo.rsa;
    public class VolatileLong extends VolatileLongPadding {
        public volatile long value = 0L;  
    }
     
    class Data {
        public VolatileLong value1 = new VolatileLong();
        public VolatileLong value2= new VolatileLong();
        public VolatileLong value3= new VolatileLong();
        public VolatileLong value4= new VolatileLong();
    }

    这里的VolatileLong 通过volatile修饰,并填充了6个无用的long占空间,加上对象头,刚好64字节

    逻辑不变,依然是线程直接操作value,而不是拷贝到内部:

    Thread t[] = new Thread[4];
            t[0] = new Thread(()-> {
                for(int i=0;i<loopcont;i++){
                    data.value1.value = data.value1.value+i;
                }
            } );
            t[1] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value2.value = data.value2.value+i;
                }
            } );
            t[2] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value3.value = data.value3.value+i;
                }
            } );
            t[3] = new Thread( () -> {
                for(int i=0;i<loopcont;i++){
                    data.value4.value = data.value4.value+i;
                }
            } );

    这个结果是:44ms,比在线程内部操作还要快。

     

     

    展开全文
  • 一直想用代码验证一下使用volatile和不适用volatile对变量可见性的影响,google找到的几个代码示例似乎都不太严密,于是写了一个,不知道是否也不严密,大家帮忙看看,如果有好的验证代码也请提供一下。先给一个不...

    一直想用代码验证一下使用volatile和不适用volatile对变量可见性的影响,google找到的几个代码示例似乎都不太严密,于是写了一个,不知道是否也不严密,大家帮忙看看,如果有好的验证代码也请提供一下。

    先给一个不使用volatile关键字,导致变量不可见的例子

    public class VolatileTest {

    private int i = 0;

    private int j = 0;

    public long exceptionCount = 0;

    //线程1调用这个方法

    public void f1() {

    for(int k = 0; k 

    i = k;

    j = i;

    }

    }

    //线程2调用这个方法

    public void f2() {

    while (true) {

    //如果线程1对i,j的修改都是可见的,就不会出现j>i的情况了,一旦出现这种情况就能说明线程1对i,j的修改不可见

    if(j > i) {

    exceptionCount++;

    }

    }

    }

    public static void main(String[] args) {

    final VolatileTest volatileTest = new VolatileTest();

    //线程1

    new Thread(new Runnable() {

    @Override

    public void run() {

    volatileTest.f1();

    }

    }).start();

    //线程2

    new Thread(new Runnable() {

    @Override

    public void run() {

    volatileTest.f2();

    }

    }).start();

    try {

    Thread.sleep(5000);

    } catch (InterruptedException e) {

    }

    System.out.println("exceptionCount:" + volatileTest.exceptionCount);

    }

    }

    输出结果为:

    exceptionCount:6542138604

    可以看到exceptionCount大于0,说明线程1对变量i,j的修改对线程2不可见。

    如果给i,j加上volatile关键字,则线程1对变量i,j的修改对线程2可见,下面给出代码:

    public class VolatileTest {

    private volatile int i = 0;

    private volatile int j = 0;

    public long exceptionCount = 0;

    public void f1() {

    for(int k = 0; k 

    i = k;

    j = i;

    }

    }

    public void f2() {

    while (true) {

    if(j > i) {

    exceptionCount++;

    }

    }

    }

    public static void main(String[] args) {

    final VolatileTest volatileTest = new VolatileTest();

    new Thread(new Runnable() {

    @Override

    public void run() {

    volatileTest.f1();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    volatileTest.f2();

    }

    }).start();

    try {

    Thread.sleep(5000);

    } catch (InterruptedException e) {

    }

    System.out.println("exceptionCount:" + volatileTest.exceptionCount);

    }

    }

    输出结果为:

    exceptionCount:0

    从结果可以看出,线程1对变量i,j的修改对线程2可见。

    展开全文
  • 我理解Java中的volatile关键字可以对引用变量和除long和double之外的所有原语进行读/写操作.我也知道复合语句,如递增整数,var,不是原子的,不应该用来代替synchronized语句.但是这堂课怎么样?public class Setter{...

    我理解Java中的volatile关键字可以对引用变量和除long和double之外的所有原语进行读/写操作.

    我也知道复合语句,如递增整数,var,不是原子的,不应该用来代替synchronized语句.

    但是这堂课怎么样?

    public class Setter{

    private int num = 0;

    public int setNum(int numIn){

    num = numIn;

    return num;

    }

    }

    现在假设您将Setter的实例声明为volatile.

    public class Main {

    private volatile Setter s;

    public static void main(String[] args){

    s = new Setter();

    s.setNum(5);

    }

    }

    是调用方法setNum原子?如果多个线程一次调用它,每个都有不同的值,这个语句是否安全?

    以正确的方式使用volatile类并在不安全的复合语句中使用它的例子是什么?

    解决方法:

    Is a call to the method setNum atomic?

    不,这不对.只有对s的读/写才是易失性的.

    这可以与将List列为最终版进行比较.这不足以使列表不可变,只有列表引用本身.

    标签:java,volatile,class

    来源: https://codeday.me/bug/20190621/1254496.html

    展开全文
  • Java volatile详解

    2021-03-29 16:53:36
    Java 语言包含两种内在的同步机制:同步块(或方法)和 volatile 变量,相比于synchronized(synchronized通常称为重量级锁),volatile更轻量级,因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性...
  • 这里也是我们用Volatile时一再说明不能用于重排的原因。下面我们就为大家分析重排导致线程不安全的实例,以及Volatile为了避免这种不安全的情况的发生,所采取的内存屏障的方法。1.Volatile重排导致线程不安全对于...
  • volatile关键字的意思是不稳定的,可变的 ...结合java的内存模型,volatile修饰的变量只会在主存里面操作,不会放入线程内存中,在主存里面操作的东西,一旦修改,所有的线程马上就可以看得见。 同时也要
  • Java volatile

    2021-01-12 15:07:02
    volatile这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它...由于volatile关键字是与Java的内存模型有关的,因此在讲述volatile关键之前,我们先来了解.
  • Java volatile原理总结

    2021-02-27 09:19:24
    内存可见性内存可见性相关概念:线程对共享变量修改的可见性。当一个线程修改了共享变量的值,其他线程能够立刻得知这个修改。...Java代码如下:Singleton volatile instance = new Singleton();...
  • java volatile关键字

    2021-02-20 21:43:32
    二、Volatile 解决了什么问题? 禁止指令重排序 保证了内存的一致性 可见性 三、什么是指令重排序 编译器和处理器会通过多种方式比如重排序对代码进行优化,然而在重排序后可能会导致运行结果与预想的不同。 重...
  • Java volatile关键字的作用volatile关键字的作用使变量在多个线程之间可见。package com.wkcto.volatilekw;/*** volatile的作用可以强制线程从公共内存中读取变量的值,而不是从工作内存中读取* Author: 老崔*/public...
  • java volatile

    2021-02-28 07:52:04
    volatile关键字解析这个关键字去网上查资料,都只是说不能保证原子性,又说有可见性,说的还是模模糊糊,例子都特么一模一样,让人读了还是不知道为啥,其实究其原因就是只叙述了一半,为啥不是线程安全的要点没有...
  • java volatile关键字使用方法及注意事项什么是volatile关键字volatile 关键字在多线程程序中起着很重要的作用。当多个线程操作同一个变量时,每个线程将拥有对那个变量的本地缓存拷贝,因此,当某一个线程修改了这个...
  • java volatile 实现变量可见性volatile 本意是易变的,多变的,用来解决变量可见性问题,什么是变量可见性问题?先看一下变量在计算机内部第一次加载和写入过程:此时,内存和寄存器中v都是101,再进行计算时时直接...
  • 在由Java语言编写的程序中。有时候为了提高程序的执行效率,编译器会自己主动对其进行优化,把经常被訪问的变量缓存起来,程序在读取这个变量的时候有可能会直接从缓存(比如寄存器)中来读取这个值。而不会去内存中...
  • I have an application which are multi ... I notice some existing code use volatile when the variable is shared by several threads. Why not just use synchronized in the method when variable is u...
  • synchronized可以禁止重排序优化 happens-before(hb) 意义:内存模型通过hb原则并发操作过程中的有序性问题 actionA先行发生actionB,就是说A对B可见(A的结果在B执行时可见)线程启动/终结规则 volatile规则, ...
  • volatile 的作用请参阅http://lizhe.name.csdn.net/node/94关于CAShttp://lizhe.name.csdn.net/node/96本文讨论volatile和CAS因false sharing的原因对性能造成的...public class Data {public volatile long value...
  • Java Volatile关键字

    2021-04-22 12:36:18
    Javavolatile关键字用于标记一个变量“应当存储在主存”。更确切地说,每次读取volatile变量,都应该从主存读取,而不是从CPU缓存读取。每次写入一个volatile变量,应该写到主存中,而不是仅仅写到CPU缓存。实际上...
  • Java中的volatile关键词被用来将变量标记为“存储在内存中”。准确地的讲每次volatile变量的读取和写入都是直接操作内存,而不是cpu cache。实际上自从java 5之后,volatile关键词保证除了volatile变量直接读写内存...
  • java volatile 关键字

    2021-02-25 19:46:42
    volatile 关键字能把 Java 变量标记成"被存储到主存中"。这表示每一次读取 volatile 变量都会访问计算机主存,而不是 CPU 缓存。每一次对 volatile 变量的写操作不仅会写到 CPU 缓存,还会刷新到主存中。实际上从 ...
  • javavolatile的作用

    2021-02-27 14:32:08
    synchronized关键字是防止多个线程同时执行一段代码,那么就会很影响程序执行效率,而volatile关键字在某些情况下性能要优于synchronized,但是要注意volatile关键字是无法替代synchronized关键字的,因为volatile...
  • 前言 通过这篇文章你将知道: 1、什么是线程同步以及...看到volatile就会想到线程同步,那么volatile能够实现线程同步吗? 两个前提:什么是线程同步?为什么要进行线程同步? 我们知道,在现代计算机原理中,中央处
  • 1. volatile关键字的作用:保证了变量的可见性(visibility)。被volatile关键字修饰的变量,如果值发生了变更,其他线程立马可见,避免出现脏读的现象。如以下代码片段,isShutDown被置为true后,doWork方法仍有执行...
  • Java volitile关键字Java volatile 关键字用来标记一个Java变量为“存储于主内存”。更准确地说是,每一次针对volatile变量的读操作将会从主内存读取而不是从CPU的缓存读取;每一次针对volatile变量的写操作都会写入...
  • Java volatile面试题

    2021-03-09 01:58:49
    Java volatile面试题volatile这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果。在Java 5之后,volatile关键字才得以重获生机...
  • Java volatile关键字详解

    2021-02-28 07:52:28
    原标题:Java volatile关键字详解原文转载自:...在Java 5之后,volatile关键字才得以重获生机。volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情。由于v...
  • Java volatile关键字

    千次阅读 2021-09-04 10:10:01
    关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制,当一个变量定义为volatile之后,它将具有两种特性。 第一是保证此变量对所有线程的可见性,这里的“可见性”是指当一条线程修改了这个变量的值,新值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 215,065
精华内容 86,026
关键字:

javavolatile

java 订阅