浅谈volatile

简介

volatile是Java语言中的一种轻量级的同步机制，它可以保证同享变量的内存可见性，也便是当一个线程修正了同享变量的值时，其他线程可以当即知道这个修正。跟synchronized相同都是同步机制，可是相比之下，synchronized属于重量级锁，volatile属于轻量级锁。

JMM概述

JMM便是Java内存模型(Java Memory Model)，是Java虚拟机标准的一种内存模型，屏蔽掉各种硬件和操作体系的内存拜访差异，以完结让Java程序在各种平台下都能到达共同的并发效果。

Java内存模型规则了Java程序的变量（包括实例变量，静态变量，可是不包括局部变量和办法参数）悉数存储在主内存中，界说了各种变量（线程的同享变量）的拜访规则，以及在JVM中将变量存储到主内存与从主内存读取变量的底层细节。

JMM的规则

• 一切同享变量都存在于主内存（包括实例变量，静态变量，可是不包括局部变量和办法参数），因为局部变量是线程私有，不存在竞赛问题。
• 每个线程都有自己的作业内存，所需求的变量是主内存中的副本。
• 线程对变量的读、写操作都只能在作业内存中完结，不能直接参与读写主内存的变量。
• 不同的线程也不能去直接拜访不同线程的作业内存的变量，线程间的变量传递需求经过主内存来中转完结。

volatile的特性

1、可见性

volatile可以保证线程的可见性，即当多个线程拜访同一个变量的时分，此变量产生改动，其他线程也能实时获得到这个修正的值。

在java中，变量都会被放在推内存(一切线程同享的内存)中，多个线程对同享内存是不行见的，当每个线程去获取这个变量的值时，实践上是copy一份副本在线程本身的作业内存中。

举个比如

咱们将main作为主线程，MyThread为子线程。在子线程中界说一个同享变量flag，主线程会去拜访这个同享变量。在不加volatile的时分，flag在主线程读到的永远是为false，因为两个线程是不行见的。

public class T2_Volatile01 {
    public static void main(String[] args) { // 主线程
        MyThread my = new MyThread();
        my.start();
        while (true) {
            if (my.isFlag()) System.out.println("进入等待...");
        }
    }
}
class MyThread extends Thread { // 子线程
    private volatile boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag = true;
        System.out.println("flag 修正完毕！");
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

实践上是现已修正了的，只是线程读的都是自己的作业内存中的数据，然而，要处理这个问题，可以运用synchronized加锁和volatile润饰同享变量来处理，这两种都能让主线程拿到子线程修正的变量的值。

synchronized (my) {
    if (my.isFlag()) System.out.println("进入等待...");
}

加了synchronized锁，首要该线程会获得锁目标，接着会去清空作业内存，再从主内存中copy一份最新的值到作业变量中，接着履行代码， 打印输出，最终释放锁。

当然还能运用volatile关键字去润饰同享变量。一开始子线程从主内存中获取变量的副本到自己的作业内存，进行改值，此刻还未写回主内存，主线程从主内存获取的变量的值也是一开始的初始值，比及子线程写回到主内存时，接下来其他线程的作业内存中此变量的副本将会失效，也便是类似于监听。在需求对此变量进行操作的时分，将会到主内存获取新的值保存到线程本身的作业内存中，然后保证了数据的共同。

总结

volatile可以保证不同线程对同享变量的可见性，也便是修正过的volatile润饰的同享变量只要被写回到主内存中，其他线程就可以立刻看到最新的数据。

当一个线程对volatile润饰的变量进行写的操作时分，JMM会当即把该线程本身的作业内存的同享变量刷新到主内存中。

当对线程进行读操作的时分，JMM会当即把当时线程本身的作业内存设置无效，然后从主内存中去获取同享变量的数据。

2、无法保证原子性

原子性指的是一项操作要么都履行，要么都不履行，半途不允许中断也不受其他线程搅扰。

举个比如

咱们看以下案例代码，简略描述一下，AutoAccretion是一个线程类，里面界说了一个同享变量count，并去履行1万次的自增，在main线程中调用多线程去履行自增。咱们所希望的结果是终究count的值是1000000，因为每个线程自增1万次，总共100个线程。

public class T3_Volatile01 {
    public static void main(String[] args) {
        Runnable thread = new AutoAccretion();
        for (int i = 1; i <= 100; i++) {
            new Thread(thread, "线程" + i).start();
        }
    }
}
class AutoAccretion implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            count++;
            System.out.println(Thread.currentThread().getName() + "count ==> " + count);
        }
    }
}

分析

count++操作首要会从主内存中拷贝变量副本到作业内存中，在作业内存中进行自增操作，最终将作业内存的数据写回主内存中。运转之后会发现，count的值是没办法到达1百万的。主要原因是count++自增操作并不是原子性的，也便是说在进行count++的时分或许被其他线程打断。

当线程1拿到count=0，进行自增后count=1，可是还没写到主内存，线程2获取的数据或许也是count=0，经过自增count=1，两者在写回内存，就会导致数据的错误。

运用volatile对原子性测试

现在经过volatile去润饰同享变量，运转之后，发现任然没办法到达一百万。

运用锁的机制

经过运用synchronized锁对代码快进行加锁，然后保证原子性，保证某个线程对count进行操作不受其他线程的搅扰。

class AutoAccretion implements Runnable {
    private volatile int count = 0; // 并发下可见性
    @Override
    public void run() {
        synchronized (this) {
            for (int i = 1; i <= 10000; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + "count ==> " + count);
            }
        }
    }
}

经过验证可以知道可以完结原子性。

总结

在多线程下，volatile关键字可以保证同享变量的可见性，可是不能保证对变量操作的原子性，因而，在多线程下即便加了volatile润饰的变量也是线程不安全的。要保证原子性就得经过加锁的机制。

除了这个办法，Java还能用过原子类（java.util.concurrent.atomic包） 来保证原子性。

3、制止指令重排

什么是指令重排序

指令重排序：为了进步程序功能，编译器和处理器会对代码指令的履行次序进行重排序。

良好的内存模型实践上会经过软件和硬件一起尽或许进步履行效率。JMM对底层约束尽量削减，在履行程序时，为了进步功能，编译器和处理器会对指令进行重排序。

一般重排序有以下三种：

• 编译器优化的重排序：编译器在不改动单线程程序语义可以对履行次序进行排序。
• 指令集并行的重排序：如果指令不存在相互依赖，那么指令可以改动履行的次序，然后可以削减load/store操作。
• 内存体系的重排序：处理器运用缓存和读/写缓存区，使得加载和存储操作是乱序履行的。

重排序怎样进步履行速度

在不改动结果的时分，对履行进行重排序，可以进步处理速度。重排序后可以使处理指令履行的更少，削减指令操作。

重排序的问题所在

因为重排序，直接或许带来的问题便是导致终究的数据不对，经过以下比如来看，如果履行的次序不同，终究得到的结果是不相同的。

public class T4_Reordering {
    public static int a = 0, b = 0;
    public static int i = 0, j = 0;
    public static void main(String[] args) throws InterruptedException {
        int count = 0;
        while (true) {
            count++;
            // 初始化
            a = 0;
            b = 0;
            i = 0;
            j = 0;
            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    a = 1;
                    i = b;
                }
            });
            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    b = 1;
                    j = a;
                }
            });
            one.start();
            two.start();
            one.join(); // 保证线程都履行完毕
            two.join();
            System.out.println("第" + count + "次线程履行：i = " + i + ", j = " + j );
            if (i == 0 && j == 0) return;
        }
    }
}

正常当线程都履行完毕之后，最终得到的值应该是i=1, j=1。经过不断的循环履行可以看到，出现的结果会犯错，领先履行了j=a(此刻a=0)在履行了a=1，i=b(此刻b=0)，b=1，最终就会导致i=0，j=0

volatile制止指令重排序

运用volatile可以完结制止指令重排序，然后保证并发安全，那么volatile是怎么完结制止指令重排序呢？便是经过运用内存屏障(Memory Barrier)。

内存屏障(Memory Barrier) 效果

• 内存屏障****可以阻止屏障两侧的指令重排序，可以让cpu或许编译器在内存上的拜访是有序的。
• 强制把写缓冲区/高速缓存中的脏数据写回主内存，或让缓存相应的数据失效。他是一种cpu指令，用来控制特定情况下的重排序和内存可见性问题。

volatile内存屏障的插入战略

硬件层的内存屏障(Memory Barrier)有Load Barrier 和 Store Barrier即读屏障和写屏障。

Java内存屏障

• StoreStore屏障：保证在该屏障之后的第一个写操作之前，屏障前的写操刁难其他处理器可见（刷新到内存）。
• StoreLoad屏障：保证写操刁难其他处理器可见（刷新到内存）之后才能读取屏障后读操作的数据到缓存。
• LoadLoad屏障：保证在该屏障之后的第一个读操作之前，一定能先加载屏障前的读操刁难应的数据。
• LoadStore屏障：保证屏障后的第一个写操作写出的数据对其他处理器可见之前，屏障前的读操作读取的数据一定先读入缓存。

在volatile润饰的变量进行写操作时分，会运用StoreStore屏障和StoreLoad屏障，进行对volatile变量读操作会在之后运用LoadLoad屏障和LoadStore屏障。