并发编程三大个性

原子性

一个操作或者屡次操作，要么所有的操作全副都失去执行并且不会受到任何因素的烦扰而中断，要么所有的操作都执行，要么都不执行。

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

如果须要更大范畴的原子性保障，能够应用synchronized关键字满足。

可见性

当一个变量对共享变量进行了批改，另外的线程都能立刻看到批改后的最新值。

volatile保障共享变量可见性，除此之外，synchronized和final都能够实现可见性。

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

final：被final润饰的字段在结构器中一旦被初始化实现，并且结构器没有把this的援用传递进来，其余线程中就可能看见final字段的值。

有序性

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

CPU缓存模型是什么

高速缓存为何呈现？

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必波及到数据的读取和写入。因为程序运行过程中的长期数据是寄存在主存（物理内存）当中的，这时就存在一个问题，因为CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因而如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。

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

图源：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;      //1y = x;       //2x ++;        //3x = 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解决的问题

保障了不同线程对共享变量【类的成员变量，类的动态成员变量】进行操作是时的可见性，一个线程批改了某个变量的值，新值对其余线程来说是立刻可见的。
禁止指令重排序。

举个简略的例子，看上面这段代码：

//线程1boolean volatile stop = false;while(!stop){    doSomething();}//线程2stop = 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的实例。
如果感觉本文对您有帮忙，点赞珍藏反对一下