【多线程 五】volatile关键字与内存可见性详解

前言：

本篇博客内容较多，方便大家查看是否是自己所需要的，用导图引导一下：

1、为什么会有volatile关键字?

之前的内容我们都是用synchronize关键字进行同步，但是synchronized的效率低，每次都要cpu判断有没有锁，有锁就会阻塞。所以说synchronized是一个重量级的锁，比较耗费资源，因此引出vllatile，volatile相对synchronized 是一个轻量级的锁。

2、volatile特点

（1）保证内存可见性

只要有一个线程将变量的值改了，马上就会同步到内存，其他的线程马上就可以得到这个改过后的值。

（2）不保证原子性

原子性：我们把一个或者多个操作在CPU执行的过程中不被中断的特性称为原子性，要么同时成功，要么同时失败。而volatile不具有此特性。

（3）禁止指令重排 (保证有序性)

有序性指的是程序按照代码的先后顺序执行

3、什么是内存可见性

3.1引出JMM（java内存模型 Java Memory Model）

JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。

由于jvm运行程序的实体是线程，每个线程创建的时候jvm 都会给自己创造一个工作内存（栈空间）工作内存（实际不存在）是每个线程的私有区域，但是java内存模型中规定所有的变量都存储在主内存，主内存是所有线程都可以访问的空间。但是线程对变量的操作（读取和赋值）都是在自己的工作空间内完成，首先要将变量拷贝到自己的工作空间，然后对变量进行操作，操作完成再将变量写回到主内存。线程是不能直接操作主存中的变量，线程间的通信必须通过主存来完成，简要访问过程如下图：

3.2JMM关于同步规定:

1.线程解锁前,必须把共享变量的值刷新回主内存
2.线程加锁前,必须读取主内存的最新值到自己的工作内存
3.加锁解锁是同一把锁

以上三点也是synchronized的规定，说明synchronized它可以实现可见性。

3.3JMM 的特性

(1) 内存可见性

可能存在一个线程AAA修改了共享变量X的值还未写回主内存中时 ,另外一个线程BBB又对内存中的一个共享变量X进行操作,但此时A线程工作内存中的共享变量X对线程B来说并不不可见.这种工作内存与主内存同步延迟现象就造成了可见性问题. 也就是说多个线程之间操作共享数据彼此是不可见的

（2）原子性

（3）有序性

4、验证volatile的内存可见性

volatile内存可见性的代码验证

public class TestVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();
        while (true) {
            if (td.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class ThreadDemo implements Runnable {
    private boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());

    }
    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

运行结果：

运行结果为flag=true
上面的程序中共有两个线程，一个是td ,一个是主线程，此时td线程修改了值，但是主线程就是没有获得到，这里可以根据上面的JMM得到答案，就是说此时有一块主存，线程td从主存中读取的flag=false，此时睡眠0.2秒，主线程从主存中也读取了flag=false。0.2秒过后，td线程中flag=true，但是main线程中while(true)执行的速度特别快，是计算机比较底层的代码，所以main线程一直都没有机会再次从主存中读取数据（此时他也不知道主存的数据被更改）。这两个线程之间操作共享数据彼此是不可见的。

在java多线程编程核心技术一书中（121页）也明确解释了上面的特性，一开始 private boolean flag = false存在于公共堆栈及线程的私有堆栈中，在JVM被设置为-server模式时为了线程运行的效率，线程一直在私有堆栈中取得flag=flase，代码 flag = true虽然被执行，更新的却是公共堆栈中的flag=true，所以一直是循环状态。

我们解决此问题的办法有很多，可以用synchronized 同步锁来解决，每次都能刷新内存
代码如下：

  public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();
        while (true) {
            synchronized (td) {  // 同步锁，可以解决，因为每次都可以刷新缓存
                if (td.isFlag()) {
                    System.out.println("------------------");
                    break;
                }
            }
        }
    }

执行结果：

但是synchronized是重量级的（因为每次都要判断有没有锁），比较耗费性能，我们引出关键字volatile(轻量级同步策略)，当主存中的值改变的时候，可以及时通知其他线程。
代码如下：

public class TestVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();
        while (true) {
            if (td.isFlag()) {
                System.out.println("------------------");
                break;
            }
        }
    }
}

class ThreadDemo implements Runnable {
    // 给变量加上volatile关键字，实现内存可见性
    private volatile boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
        flag = true;
        System.out.println("flag=" + isFlag());

    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

执行结果带着横线：

5、验证volatile不具备原子性

代码：

public class TestVolatile1 {
    public static void main(String[] args) {
        myData myData=new myData();
        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                for (int j = 0; j <1000 ; j++) {
                    myData.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount()>2){ //使用IntelliJ IDEA的读者请注意，
       // 在IDEA中运行这段程序，会由于IDE自动创建一条名为Monito rCtrl-Break的线程,所以为2
            Thread.yield();//当前线程由执行态变为就绪态，让出cpu
        }
        System.out.println(myData.num);
    }
}

class myData{
     volatile int num=0;
    public void addPlusPlus(){
        this.num++;
    }
}

每次结果都不一样，并且不是20000，说明不具有原子性。

这里我们得出一个结论 num++ 在多线程下是不安全的

因为num++ 实际上是分三步的，

第一步：栈中取出i
第二步：i自增1
第三步：将i存到栈

接下来我们反编译可以进行验证，在idea终端（Terminal）输入javap -p -v myData.class，然后找到方法addPlusPlus，如下图，我们看到了加载，自增，然后存栈等步骤。

尽管用了volatile 第三步能够及时写入到内存。但是它不具备原子性，比如线程A从栈中取出i,此时完成了自增，发生了线程调度，此时线程B取出栈的值，尽管线程A里的值发生了更改，但是还未写到栈里，此时线程B操作的还是之前的值。这就证明了volatile不具备原子性。

5.1 如何解决原子性

其实synchronized可以解决，但是杀鸡焉能用牛刀，它太重量级了，我们有解决办法，那就是Atomic包（CAS的应用，CAS具体理论我们篇文章会仔细分析）。

public class TestVolatile1 {
    public static void main(String[] args) {
        myData myData=new myData();
        for (int i = 0; i <20 ; i++) {
            new Thread(()->{
                for (int j = 0; j <1000 ; j++) {
                    myData.addAtomic();
                }
            },String.valueOf(i)).start();
        }
        while (Thread.activeCount()>2){ //java最起码有一个main线程，和一个垃圾回收线程
            Thread.yield();//当前线程由执行态变为就绪态，让出cpu
        }
        System.out.println(Thread.currentThread().getName()+"\t" +myData.atomicInteger);
    }
}

class myData{
    AtomicInteger atomicInteger=new AtomicInteger();  // 不用赋值，默认就是0
    public void addAtomic(){
        atomicInteger.getAndIncrement();// 表示i++
    }
}

结果：20000,证明保证了原子性。

6、volatile禁止指令重排序分析

前提条件：计算机在执行程序的时候，为了提高性能，编译器和处理器会对指令进行重排序。

（1）单线程环境, 重排序能保证程序的最终结果和顺序执行的结果一致
（2）处理器处理重排序必须考虑指令之间的数据依赖性(如b依赖a, 不能将b排序在a之前执行)
（3）多线程调度过程中, 由于重排序存在, 两个线程的变量无法保证一致性

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

比如两个线程如下（只是举例）

此时线程如果线程1的执行顺序a=1，flag=true，则线程2输出的结果为6，如果此时线程1排序后，先执行了flag=true，还未执行a=1,那么此时恰巧线程2获取了flag=true，最终结果就是5了。解决这个问题 变量前用volatile关键字就可以解决。

7、volatile和synchronized的区别

（1）volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
（2）volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别
（3）volatile不能保证原子性；而synchronized则可以保证原子性
（4）volatile不会造成线程的阻塞，没有互斥性；synchronized可能会造成线程的阻塞。具有互斥性。
（5）volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化