对volatile的理解

时间 2019-11-07

标签 volatile 理解栏目 Java 繁體版

原文原文链接

JMM 是什么

JMM（java内存模型 Java Memory Model）自己是一种抽象的概念，描述一组规则后规范经过这组规范定义了程序中各个变量（包括实例字段，静态变量和组成数组对象的元素）的访问方式。java

JMM关于同步的规定：数组

线程解锁前，必须把共享变量的值刷新回主内存
线程加锁前，必须读取主内存的最新值到本身的工做内存
加解锁是同一把锁

因为JMM运行程序的实体是线程，而每一个线程建立JVM都会为其建立一个工做内存，工做内存是每一个线程的私有数据区域，而Java内存模型中规定全部变量都存储在 主内存，主内存是共享内存区域，全部线程均可以访问，但线程对变量的操做（读取或赋值）必须在工做内存中进行，首先要将内存从主内存拷贝到本身的工做内存空间，而后对变量进行操做，操做完成后再将变量写回到主内存，不能直接操做主内存中的变量，各个线程中的工做内存中存储着主内存中的变量副本拷贝，所以不一样的线程间没法访问对方的工做内存，线程间的通讯（值传递）必须经过主内存来完成。访问过程以下：安全

JMM三个特性（约束）

可见性
原子性
有序性

volatile是什么

volatile是Java虚拟机提供的轻量级同步机制多线程

保证可见性
不保证原子性
禁止指令重排

什么是可见性

public class VolatileDemo {
    public static void main(String[] args) throws InterruptedException {
        MyData myData = new MyData();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.add60();
            System.out.println(Thread.currentThread().getName()+ " 线程内修改num的值为 ：" + myData.number);
        }, "Thread1").start();

        while (myData.number == 0) {

        }
        TimeUnit.SECONDS.sleep(4);
        System.out.println(Thread.currentThread().getName()+ " 主线程从循环中跳出");
    }
}

class MyData {
    volatile int number = 0;

    void add60() {
        this.number = 60;
    }
}
复制代码

以上代码执行结果为性能

Thread1  线程内修改num的值为 ：60
main   主线程从循环中跳出
复制代码

由结果可知，线程之间是有可见性的，即线程Thread1 修改了number的值为60，主线程的工做内存中的number读到修改后的值为60，便跳出循环，输出循环外的语句。优化

若是将classData中的number去掉volatile的修饰，则线程间没有可见性，即主线程读不到number修改后的值，main的工做内存中仍是保留number值为0，则一直停留在循环中。this

什么是原子性

不可见分割，完整性，某个线程正在作某个具体业务时，中间不可被加塞或者分割，须要总体完成，要么成功，要么失败。spa

public class VolatileAtomicity {
    public static void main(String[] args) {
        MyDatas myDatas = new MyDatas();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    myDatas.numPlusPlus();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(myDatas.number);
    }
}

class MyDatas {
    volatile int number = 0;

    void numPlusPlus() {
        number++;
    }
}
复制代码

以上代码执行结果老是小于2000
首先咱们知道 number++ 操做是分两步执行：线程

获取当前number的值
number++
结果放回主内存中。
根据上述，volatile修饰的number是不保证原子性的，也就是在执行number++的过程会被其余线程打断，即A线程获取number的值为1时，同时B线程也获取了number的值为1，A进行第二步number+1，而后第三步准备将结果2放回主内存时，线程B抢先一步将其工做内存中number+1的结果2放回主内存，理论上A/B两个线程各加了1，结果应该为3，可是实际上A线程计算结果也是2，放回主内存时只是覆盖了B线程的结果，最终主内存中的结果在通过两个线程分别+1后仍是2.

以上，可知volatile是不符合JMM规定的原子性的，同时number++在多线程下是非线程安全的。code

如何解决原子性问题

加synchronized
使用原子类AtomicInteger
使用synchronized对于此场景来讲过重，所以优先考虑使用AtomicInteger做为number的类型。

有序性

volatile的有序性表如今 禁止指令重排    
复制代码

指令重排

计算机在执行程序时，为了提升性能，编译器和处理器经常会对指令作重排，通常分为三类：

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致
处理器在进行重排序时必须考虑指令间的数据依赖性
多线程环境中线程交替执行，因为编译器优化重排的存在，两个线程中使用的变量可否保证一致性是没法肯定的，结果没法预测

void mysort() {
        int x = 11;
        int y = 12;
        x = x + 5;
        y = x * x;
    }
复制代码

以上代码，执行顺序 123四、213四、1324 是不影响最终的结果的，所以代码编译后指令顺序不必定为1234，这种行为在多线程下可能会形成结果的偏差。

public class ReSoreSeqDemo {
    int a = 0;
    boolean flag = false;

    public void method1() {
        a = 1;
        flag = true;
    }

    public void method2() {
        if (flag) {
            a = a + 5;
            System.out.println("****value = " + a);
        }
    }
}
复制代码

如上代码，现有两个线程A/B，分别执行method1和2，仅对于线程A来讲，method1方法两行执行顺序前后没有关系。可是若是method1顺序变了，先执行flag=true，这时线程B就进入method2的判断中，a=5，再接着执行线程A的 a=1，最后结果为 a = 1，与指望结果 a=1 而后 a = a+5 的结果有差别。这就是须要禁止指令重排的缘由。

volatile实现禁止指令重排优化，从而避免多线程环境下环境出现乱序执行的现象。

内存屏障(Memory Barrier)

内存屏障又称内存栅栏，是一个CPU指令，他的做用有两个：

保证特定操做的执行顺序
保证某些变量的内存可见性(利用该特性实现volatile的内存可见性)

因为编译器和处理器都能执行指令重排优化。若是在指令间插入一条MemoryBarrier则会告诉编译器和CPU，无论什么指令都不能和这条MemoryBarrier指令重排序，也就是经过内存屏障禁止在内存屏障先后的指令执行重排序优化。内存屏障另外的一个做用是强制刷出各类CPU的焕醋拿数据，所以任何CPU上的线程都能读取到这些数据的最新版本。

对volatile变量进行写操做时，会在写操做后加入一条store屏障指令，将工做内存中的共享变量之刷新到主内存中；
对volatile变量进行读操做时，会在读操做前加入一条load屏障指令，从主内存中读取共享变量

线程安全如何得到保障

工做内存和主内存同步延迟现象致使的可见性问题

可使用synchronized或volatile关键字解决，他们均可以是一个线程修改后的变量当即对其余线程可见

对于指令重排致使的可见性问题和有序性问题

能够利用volatile关键字解决，由于volatile的另外一个做用就是禁止重排指令优化

本文结束
内容根据尚硅谷视频总结
欢迎访问个人我的博客 justd的博客