JUC并发编程学习笔记(十六)Volatile

Volatile

保证可见性

private volatile static Integer num = 0;

使用了volatile关键字,即可保证它本身可被其他线程的工作内存感知,即变化时也会被同步变化。

不保证原子性

原子性:不可分割

线程A在执行任务时是不可被打扰的,也不能被分割,要么同时成功,要么同时失败。

package org.example.tvolatile;

public class VDemo02 {
    //synchronized保证原子性,每次只有一条线程执行,所以结果准确
    //volatile不保证原子性,虽然也是同步机制,但是结果不准确
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){//主线程和GC线程
            Thread.yield();//让主线程礼让
        }
        System.out.println(num);
    }

}

每次结果也不一样。

如果不加Lock加synchronized,怎么保证原子性?

要了解为什么一个num++都不能保证原子性,首先我们需要查看到他编译好的class字节码文件,找到target,并且右键选择打开外部的文件,找到对应的class文件,再通过javap -c命令反编译查看字节码文件。

查看到字节码文件后可以看到从底层看,其实num++这个操作再多线程下并不安全,有获取和写回这两个操作

那么又回到了这个问题,在volatile中如何保证原子性。打开jdk帮助文档,我们能找到原子性的一些数据类型

在volatile需要保证原子性操作的时候使用原子类来解决原子问题。

原子类为什么高级

原子类的包装类底层使用的是CAS操作。

package org.example.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

public class VDemo02 {
    //synchronized保证原子性,每次只有一条线程执行,所以结果准确
    //volatile不保证原子性,虽然也是同步机制,但是结果不准确
    private volatile static AtomicInteger num = new AtomicInteger(0);
    public static void add(){
        num.getAndIncrement();//AtomicInteger+1的方法,并不是简单的+1操作,方法:CAS
    }
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){//主线程和GC线程
            Thread.yield();//让主线程礼让
        }
        System.out.println(num);
    }

}

这些类的底层都直接调用c++和操作系统挂钩!在内存中修改值。Unsafe类是一个很特殊的存在!Unsafe类的所有方法都是native方法,调用c++底层

native是与C++联合开发的时候用的!java自己开发不用的!

禁止指令重排

什么是指令重排:你写的程序并不是按照你写的那样去执行的

源代码-----编译器优化的指令重排--------指令并行也可能会指令重排--------内存系统也会重排--------->执行

int x = 1;//1
int y = 2;//2
x = x+5;//3
y = x*x;//4

我们所期望的执行顺序:1、2、3、4;但是如果按照1、3、2、4或者2、4、1、3的顺序执行也是能够顺利运行的,计算机执行时可能对对我们所期望执行顺序的程序进行指令重排,结果是正确的但是对运行顺序有所不同

但是指令重排后的顺序不可能是4、3、2、1或者其它不符合逻辑的顺序。因为处理器在进行指令重拍的过程中会考虑数据之间的依赖性

可能造成影响的结果:四个初始值都为零

线程A 线程B
x = a; y = b;
b = 1; a = 2;

由于两个线程的操作都没有数据依赖性,指令重排就不会考虑顺序问题,可能会导致最终的执行顺序如下

线程A 线程B
b = 1; a = 2;
x = a; y = b;

多线程下可能导致一些问题

正常结果:x=0;y=0;

指令重排导致的诡异结果:x=2;y=1;

这是一种概念可能你写1000w行代码都不一定会出现,但是在理论上是一定会参数的。

volatile可以避免指令重排

计算机中存在着一种指令叫做内存屏障,它是一种CPU指令。

作用:

1、保证特定操作的执行顺序(可以让volatile避免指令重排)

2、可以保证某些变量的内存可见性(可以让volatile实现可见性)

Volatile保证可见性、不能保证原子性、由于内存屏障,可以避免指令重排的现象产生!

内存屏障在单例模式中使用的最多!

热门相关:亲戚姐姐   爱欲轮回   她的情事   我的继母   高甜预警:我家影后超猛的