【Java并发编程】从CPU缓存模型到JMM来理解volatile关键字

时间 2020-09-22

标签 Java并发编程 cpu 缓存模型 jmm 理解 volatile 关键字栏目 Java 繁體版

原文原文链接

并发编程三大特性

原子性

一个操做或者屡次操做，要么全部的操做所有都获得执行而且不会受到任何因素的干扰而中断，要么全部的操做都执行，要么都不执行。html

对于基本数据类型的访问，读写都是原子性的【long和double可能例外】。java

若是须要更大范围的原子性保证，可使用synchronized关键字知足。git

可见性

当一个变量对共享变量进行了修改，另外的线程都能当即看到修改后的最新值。面试

volatile保证共享变量可见性，除此以外，synchronized和final均可以实现可见性。编程

synchronized：对一个变量执行unclock以前，必须先把此变量同步回主内存中。缓存

final：被final修饰的字段在构造器中一旦被初始化完成，而且构造器没有把this的引用传递出去，其余线程中就可以看见final字段的值。多线程

有序性

即程序执行的顺序按照代码的前后顺序执行【因为指令重排序的存在，Java 在编译器以及运行期间对输入代码进行优化，代码的执行顺序未必就是编写代码时候的顺序】，volatile经过禁止指令重排序保证有序性，除此以外，synchronized关键字也能够保证有序性，由【一个变量在同一时刻只容许一条线程对其进行lock操做】这条规则得到。并发

CPU缓存模型是什么

高速缓存为什么出现？

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程当中，势必涉及到数据的读取和写入。因为程序运行过程当中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，因为CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，所以若是任什么时候候对数据的操做都要经过和内存的交互来进行，会大大下降指令执行的速度。app

为了解决CPU处理速度和内存不匹配的问题，CPU Cache出现了。ide

图源：JavaGuide

缓存一致性问题

当程序在运行过程当中，会将运算须要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就能够直接从它的高速缓存读取数据和向其中写入数据，当运算结束以后，再将高速缓存中的数据刷新到主存当中。

在单线程中运行是没有任何问题的，可是在多线程环境下问题就会显现。举个简单的例子，以下面这段代码：

i = i + 1;

按照上面分析，主要分为以下几步：

从主存读取i的值，复制一份到高速缓存中。
CPU执行执行执行对i进行加1操做，将数据写入高速缓存。
运算结束后，将高速缓存中的数据刷新到内存中。

多线程环境下，可能出现什么现象呢？

初始时，两个线程分别读取i的值，存入各自所在的CPU高速缓存中。
线程T1进行加1操做，将i的最新值1写入内存。
此时线程T2的高速缓存中i的值仍是0，进行加1操做，并将i的最新值1写入内存。

最终的结果i = 1而不是i = 2，得出结论：若是一个变量在多个CPU中都存在缓存（通常在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

如何解决缓存不一致

解决缓存不一致的问题，一般来讲有以下两种解决方案【都是在硬件层面上提供的方式】：

经过在总线加LOCK#锁的方式

在早期的CPU当中，是经过在总线上加LOCK#锁的形式来解决缓存不一致的问题。由于CPU和其余部件进行通讯都是经过总线来进行的，若是对总线加LOCK#锁的话，也就是说阻塞了其余CPU对其余部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。好比上面例子中若是一个线程在执行 i = i +1，若是在执行这段代码的过程当中，在总线上发出了LCOK#锁的信号，那么只有等待这段代码彻底执行完毕以后，其余CPU才能从变量i所在的内存读取变量，而后进行相应的操做。这样就解决了缓存不一致的问题。

但，有一个问题，在锁住总线期间，其余CPU没法访问内存，致使效率低下，因而就出现了下面的缓存一致性协议。

经过缓存一致性协议

较著名的就是Intel的MESI协议，MESI协议保S证了每一个缓存中使用的共享变量的副本是一致的。

当CPU写数据时，若是发现操做的变量是共享变量，即在其余CPU中也存在该变量的副本，会发出信号通知其余CPU将该变量的缓存行置为无效状态，所以当其余CPU须要读取这个变量时，发现本身缓存中缓存该变量的缓存行是无效的【嗅探机制：每一个处理器经过嗅探在总线上传播的数据来检查本身的缓存的值是否过时】，那么它就会从内存从新读取。

基于MESI一致性协议，每一个处理器须要不断从主内存嗅探和CAS不断循环，无效交互会致使总线带宽达到峰值，出现总线风暴。

图源：JavaFamily 敖丙三太子

JMM内存模型是什么

JMM【Java Memory Model】：Java内存模型，是java虚拟机规范中所定义的一种内存模型，Java内存模型是标准化的，屏蔽掉了底层不一样计算机的区别，以实现让Java程序在各类平台下都能达到一致的内存访问效果。

它描述了Java程序中各类变量【线程共享变量】的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

注意，为了得到较好的执行性能，Java内存模型并无限制执行引擎使用处理器的寄存器或者高速缓存来提高指令执行速度，也没有限制编译器对指令进行重排序。也就是说，在java内存模型中，也会存在缓存一致性问题和指令重排序的问题。

JMM的规定

全部的共享变量都存储于主内存，这里所说的变量指的是【实例变量和类变量】，不包含局部变量，由于局部变量是线程私有的，所以不存在竞争问题。

每一个线程都有本身的工做内存（相似于前面的高速缓存）。线程对变量的全部操做都必须在工做内存中进行，而不能直接对主存进行操做。

每一个线程不能访问其余线程的工做内存。

Java对三大特性的保证

原子性

在Java中，对基本数据类型的变量的读取和赋值操做是原子性操做，即这些操做是不可被中断的，要么执行，要么不执行。

为了更好地理解上面这句话，能够看看下面这四个例子：

x = 10;  	//1
y = x;   	//2
x ++;    	//3
x = x + 1;  //4

只有语句1是原子性操做：直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工做内存中。
语句2实际包含两个操做：先去读取x的值，再将x的值写入工做内存，虽然两步分别都是原子操做，可是合起来就不能算做原子操做了。
语句3和4表示：先读取x的值，进行加1操做，写入新的值。

须要注意的点：

在32位平台下，对64位数据的读取和赋值是须要经过两个操做来完成的，不能保证其原子性。在目前64位JVM中，已经保证对64位数据的读取和赋值也是原子性操做了。https://www.zhihu.com/question/38816432
Java内存模型只保证了基本读取和赋值是原子性操做，若是要实现更大范围操做的原子性，能够经过synchronized和Lock来实现。

可见性

Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会保证修改的值会当即被更新到主存，当有其余线程须要读取时，它会去内存中读取新值。

另外，经过synchronized和Lock也可以保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁而后执行同步代码，而且在释放锁以前会将对变量的修改刷新到主存当中。所以能够保证可见性。

有序性

在Java内存模型中，容许编译器和处理器对指令进行重排序，可是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java里面，能够经过volatile关键字来保证有序性，另外也能够经过synchronized和Lock来保证有序性。

Java内存模型具有一些先天的有序性，前提是两个操做知足happens-before原则，摘自《深刻理解Java虚拟机》：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操做先行发生于书写在后面的操做【让程序看起来像是按照代码顺序执行，虚拟机只会对不存在数据依赖性的指令进行重排序，只能保证单线程中执行结果的正确性，多线程结果正确性却没法保证】
锁定规则：一个unLock操做先行发生于后面对同一个锁额lock操做
volatile变量规则：对一个变量的写操做先行发生于后面对这个变量的读操做
传递规则：若是操做A先行发生于操做B，而操做B又先行发生于操做C，则能够得出操做A先行发生于操做C
线程启动规则：Thread对象的start()方法先行发生于此线程的每一个一个动做
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
线程终结规则：线程中全部的操做都先行发生于线程的终止检测，咱们能够经过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

若是两个操做的执行次序没法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机能够随意地对它们进行重排序。

volatile解决的问题

保证了不一样线程对共享变量【类的成员变量，类的静态成员变量】进行操做是时的可见性，一个线程修改了某个变量的值，新值对其余线程来讲是当即可见的。
禁止指令重排序。

举个简单的例子，看下面这段代码：

//线程1
boolean volatile stop = false;
while(!stop){
    doSomething();
}
//线程2
stop = true;

线程1和2各自都拥有本身的工做内存，线程1和线程2首先都会将stop变量的值拷贝一份放到本身的工做内存中，
共享变量stop经过volatile修饰，线程2将stop的值改成true将会当即写入主内存。
线程2写入主内存以后，致使线程1工做内存中缓存变量stop的缓存行无效。
线程1的工做内存中缓存变量stop的缓存行无效，致使线程1会再次从主存中读取stop值。

volatile保证原子性吗？怎么解决？

volatile没法保证原子性，如对一个volatile修饰的变量进行自增操做i ++，没法保证多线程下结果的正确性。

解决方法：

使用synchronized关键字或者Lock加锁，保证某个代码块在同一时刻只能被一个线程执行。
使用JUC包下的原子类，如AtomicInteger等。【Atomic利用CAS来实现原子操做】。

volatile的实现原理

下面这段话摘自《深刻理解Java虚拟机》：

观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。

lock前缀指令实际上至关于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

它确保指令重排序时不会把其后面的指令排到内存屏障以前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操做已经所有完成；

它会强制将对缓存的修改操做当即写入主存；

若是是写操做，它会致使其余CPU中对应的缓存行无效。

volatile和synchronized的区别

volatile变量读操做的性能消耗与普通变量几乎没有什么差异，可是写操做则会慢一些，由于它须要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。不过即使如此，大多数场景下volatile的总开销仍然要比锁来的低。

volatile只能用于变量，而synchronized能够修饰方法以及代码块。
volatile能保证可见性，可是不能保证原子性。synchronized二者都能保证。若是只是对一个共享变量进行多个线程的赋值，而没有其余的操做，推荐使用volatile，它更加轻量级。
volatile 关键字主要用于解决变量在多个线程之间的可见性，而 synchronized 关键字解决的是多个线程之间访问资源的同步性。

volatile的使用条件

使用volatile必须具有两个条件【保证原子】：

对变量的写操做不依赖于当前值。
该变量没有包含在具备其余变量的不变式中。

volatile与双重检查锁实现单例

用双重检查锁的方式实现单例模式：

public class Singleton {
	//注意使用volatile防止指令重排序
    private volatile static Singleton instance;
	//私有化构造方法，单例模式基本操做
    private Singleton() {
    }
	//静态获取单例的方法
    public  static Singleton getInstance() {
       //先判断对象是否已经实例过，没有实例化过才进入加锁代码
        if (instance == null) {
            //类对象加锁
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

使用volatile的缘由：防止指令重排序。

instance= new Singleton();这一步，是一个实例化的过程，底层其实分为三部执行：

为instance分配内存空间：memory = allocate();

实例化instance。ctorInstance(memory);

将instance指向分配的内存地址。instance = memory;

因为JVM具备指令重排序的特性，指令的执行顺序可能会变成1，3，2。在多线程环境下，可能某个线程可能会获得未初始化的实例。

举个例子：加入线程A执行了1和2以后，线程B调用getInstance的时候，会发现instance不为null，会直接返回这个没有执行过指令3的实例。

参考

javaguide
Java并发编程：volatile关键字解析 Matrix海子
面试官想到，一个Volatile，敖丙都能吹半小时
《Java并发编程的艺术》方腾飞
《深刻理解Java虚拟机》周志明