volatile关键字

1，多线程的三个特性？

• 原子性
  即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执。
• 可见性
  可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
• 有序性
  即程序执行的顺序按照代码的先后顺序执行

2，可见性问题的来源？

1. 背景： 计算机核心组件：CPU、内存、I/O设备，三者在处理速度上存在巨大差异，CPU速度最快>内存>I/O设备（磁盘）。
   为了提升计算性能，CPU从单核提升到了多核，甚至用到了超线程技术最大化提高CPU处理性能，如果后两者处理性能没有跟上，意味着整体的计算效率取决于最慢的设备。为了平衡三者之间的速度差异，最大化的利用CPU提升性能，从硬件、操作系统、编译器等方面，做出了很多优化：
   【硬件层面优化】CPU增加高速缓存
   【操作系统层面优化】操作系统增加了进程和线程：通过CPU的时间片切换最大化的提升CPU的使用率。
   【编译器层面优化】编译器指令优化：更合理的去利用好CPU的高速缓存。
2. 计算机中大部分运行任务不能只依靠CPU“计算”就能完成，CPU还需要与Memory交互，比如读取运算数据、存储运算结果，这个 I/O 操 作是很难消除的。
   
   而由于计算机的存储设备与处理器的运算速度差距非常大，所以现代计算机系统都会增加一层读写速度尽可能接近处理器运算速度的高速缓存来作为内存 和处理器之间的缓冲:将运算需要使用的数据复制到缓存中，让运算能快速进行，当运算结束后再从CPU缓存同步到内存之中。
3. 缓存一致性问题
   每个 CPU 的处理过程是， 先将计算需要用到的数据缓存在 CPU 高速缓存中，在 CPU 进行计算时，直接从高速缓存中读取数据并且在计算完成之后写入到缓存中。在整个运算过程完成后，再把缓存中 的数据同步到主内存。
   由于在多 CPU 种，每个线程可能会运行在不同的 CPU 内， 并且每个线程拥有自己的高速缓存。同一份数据可能会被缓存到多个 CPU 中，如果在不同 CPU 中运行的不同线程看到同一份内存的缓存值不一样就会存在缓存不一致的问题。
   为了解决缓存不一致的问题，在 CPU 层面做了很多事情， 主要提供了两种解决办法：
   解决方案一：总线锁
   在多 cpu 下，当其中一个处理器要对共享内存进行操作的时候，在总线上发出一个 LOCK# 信号，这个信号使得其他处理器无法通过总线来访问到共享内存中的数据，总线锁定把 CPU 和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，总线锁定的开销比较大，这种机制显然是不合适的。多个CPU访问数据的时候互斥的问题，这样让CUP并行变为串行。

总线锁的优化的方式是控制锁的粒度

解决方案二：缓存锁
所谓缓存锁，就是指内存区域如果被缓存在处理器的缓存行中，并且在Lock期间被锁定，那么当它执行锁操作回写到内存时，不再总线上加锁，而是修改内部的内存地址，基于缓存一致性协议来保证操作的原子性。（相比总线锁，缓存锁即降低了锁的力度。核心机制是基于缓存一致性协议来实现的。）

4.缓存一致性协议
MSI ，MESI 、MOSI …

为了达到数据访问的一致，需要各个处理器在访问缓存时遵循一些协议，在读写时根据协议来操作，常见的协议有MSI，MESI，MOSI等。最常见的就是MESI协议。接下来给大家简单讲解一下MESI
MESI表示缓存行的四种状态，分别是

• M(Modify) 表示共享数据只缓存在当前CPU缓存中，并且是被修改状态，也就是缓存的数据和主内存中的数据不一致
  

• E(Exclusive) 表示缓存的独占状态，数据只缓存在当前CPU缓存中，并且没有被修改（独占状态只有一个CUP 有数据）
  

• S(Shared) 表示数据可能被多个CPU缓存，并且各个缓存中的数据和主内存数据一致

• I(Invalid) 表示缓存已经失效

总线锁和缓存锁怎么选择，取决于很多因素，比如CPU是否支持、以及存在无法缓存的数据时
（比较大或者快约多个缓存行的数据），必然还是会使用总线锁。

对于 MESI 协议，从 CPU 读写角度来说会遵循以下原则:

CPU 读请求:缓存处于 M、E、S 状态都可以被读取，I 状 态 CPU 只能从主存中读取数据。
CPU 写请求:缓存处于 M、E 状态才可以被写。对于 S 状 态的写，需要将其他 CPU 中缓存行置为无效才可写 使用总线锁和缓存锁机制之后，CPU 对于内存的操作大概 可以抽象成下面这样的结构。从而达到缓存一致性效果。

5.MESI 优化带来的可见性问题
CPU 缓存行的状态是通过消息传递来进行的，如果 CPU0 要对一个在缓存中共享的变量进行写入，首先发送一个失效的消息给到其他缓存了该数据的 CPU。并且要等到他们的确认回执。CPU0 在这段时间内都会处于阻塞状态。

为了避免阻塞带来的资源浪费。在 cpu 中引入 了 Store Bufferes（存储缓存） 和 Invalidate Queue（无效队列）。
CPU0 写入共享数据时，直接把数据写入到 store bufferes 中，同时发送 invalidate 消息，然后继续去处理其他指令。
当收到其他所有 CPU 发送了 invalidate ACK消息时，再将 store bufferes 中的数据数据存储至 cache 中。最后再从本地Cache同步到主内存。

但是 cpu 中引入 Store Bufferes 优化存在两个问题：

第⑥、⑦步骤中，由于Invalidate消息进入队列后就给CPU-0返回了响应，不能保证第⑦步骤一定完成。
引入了 Store Bufferes 后，处理器会先尝试从 Store Bufferes 中读取值，如果 Store Bufferes 中有数据，则直接从Store Bufferes 中读取，否则就再从本地Cache中读取，从Store Bufferes读取数据存在脏读。

6.Store Bufferes引起的指令重排序问题

executeToCPU0(){
      a=1;
      b=1;
}
executeToCPU1(){
    while(b==1){   //b=1
     assert(a==1); //a=0
     }
}

7.通过内存屏障禁止了指令重排序

X86的memory barrier指令包括lfence(读屏障) sfence(写屏障) mfence(全屏障)

• Store Memory Barrier(写屏障) ，告诉处理器在写屏障之前的所有已经存储在存储缓存(storebufferes)中的数据同步到主内存，简单来说就是使得写屏障之前的指令的结果对屏障之后的读或者写是可见的
• Load Memory Barrier(读屏障) ，处理器在读屏障之后的读操作,都在读屏障之后执行。配合写屏障，使得写屏障之前的内存更新对于读屏障之后的读操作是可见的
• Full Memory Barrier(全屏障) ，确保屏障前的内存读写操作的结果提交到内存之后，再执行屏障后的读写操作

volatile int a=0;
executeToCpu0(){
      a=1;
      //storeMemoryBarrier()写屏障，写入到内存
      b=1;
      // CPU层面的重排序
      //b=1;
      //a=1;
}
executeToCpu1(){
      while(b==1){ //true
          loadMemoryBarrier(); //读屏障
          assert(a==1) //false
    }
}

8.java内存模型是如何解决指令重排序 和 缓存问题？
并发编程导致可见性问题的根本原因是缓存及重排序。 而JMM 实际上就是提供了合理的禁用缓存以及禁止重排序的方法。所以它最核心的价值在于解决可见性和有序性。

JMM 抽象模型分为主内存、工作内存（本地内存）;

• 主内存：是所有线程 共享的，一般是实例对象、静态字段、数组对象等存储在 堆内存中的变量。
• 工作内存（本地内存）：是每个线程独占的，线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存中的变量，线程之间的共享变量值的传递都是基于主内存来完成。
  9.JMM 是如何解决可见性有序性问题的？
  JMM 提供了一些禁用缓存以及进制重排序的方法，来解决可见性和有序性问题。这些方法大家都很熟悉: volatile、synchronized、final;
  10.JMM 如何解决顺序一致性问题？
  
  编译器重排序，JMM 提供了禁止特定类型的编译器重排序。
  处理器重排序，JMM 会要求编译器生成指令时，会插入内存屏障来禁止处理器重排序。

11,JMM的内存屏障

1、为什么会有内存屏障？
(1)CPU的高速缓存会缓存主存中的数据，缓存的目的就是为了提高性能，避免每次都要向内存取。但是这样的弊端也很明显：不能实时的和内存发生信息交换，分在不同CPU执行的不同线程对同一个变量的缓存值不同。
(2)用volatile关键字修饰变量可以解决上述问题，那么volatile是如何做到这一点的呢？那就是内存屏障。

2、内存屏障是什么?
硬件层的内存屏障分为两种：Load Barrier （读屏障） 和 **Store Barrier（写屏障）**及 Full Barrier（全屏障） 是读屏障和写屏障的合集。
内存屏障有两个作用：
(1)阻止屏障两侧的指令重排序；
(2)写屏障：强制把写缓冲区/高速缓存中的脏数据等写回主内存，读屏障：将缓冲区/高速缓存中相应的数据失效。
3、java内存屏障?
java的内存屏障通常所谓的四种即LoadLoad（LL）,StoreStore（SS）,LoadStore（LS）,StoreLoad（SL）实际上也是上述两种的组合，完成一系列的屏障和数据同步功能。
(1)LoadLoad（LL）屏障：对于这样的语句Load1; (2)LoadLoad; Load2，在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕。
(3)StoreStore（SS）屏障：对于这样的语句Store1; StoreStore; Store2，在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见。
(4)LoadStore（LS）屏障：对于这样的语句Load1; LoadStore; Store2，在Store2及后续写入操作被刷出前，保证Load1要读取的数据被读取完毕。
StoreLoad（SL）屏障：对于这样的语句Store1; StoreLoad; Load2，在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的。在大多数处理器的实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的功能。
4、volatile语义中的内存屏障?
volatile的内存屏障策略非常严格保守，非常悲观且毫无安全感的心态：
(1)在每个volatile写操作前插入StoreStore（SS）屏障，在写操作后插入StoreLoad屏障；
(2)在每个volatile读操作前插入LoadLoad（LL）屏障，在读操作后插入LoadStore屏障；

由于内存屏障的作用，避免了volatile变量和其它指令重排序、线程之间实现了通信，使得volatile表现出了轻量锁的特性。

5、final语义中的内存屏障?
对于final域，编译器和CPU会遵循两个排序规则：
(1)、新建对象过程中，构造体中对final域的初始化写入和这个对象赋值给其他引用变量，这两个操作不能重排序；
(2)、初次读包含final域的对象引用和读取这个final域，这两个操作不能重排序；（意思就是先赋值引用，再调用final值）
总之上面规则的意思可以这样理解：必需保证一个对象的所有final域被写入完毕后才能引用和读取。这也是内存屏障的起的作用：
1、写final域：在编译器写final域完毕，构造体结束之前，会插入一个StoreStore屏障，保证前面的对final写入对其他线程/CPU可见，并阻止重排序。
2、读final域：在上述规则2中，两步操作不能重排序的机理就是在读final域前插入了LoadLoad屏障。
3、X86处理器中，由于CPU不会对写-写操作进行重排序，所以StoreStore屏障会被省略；而X86也不会对逻辑上有先后依赖关系的操作进行重排序，所以LoadLoad也会变省略。

11.HappenBefore原则
HappenBefore解决的是可见性问题
定义：前一个操作的结果对于后续操作是可见的。在 JMM 中，如果一个操作执行的结果需要对另一个操作课件，那么这两个操作必须要存在 happens-before 关系。这两个操作可以是同一个线程，也可以是不同的线程。

1、as-if-serial 规则（程序顺序执行）：单个线程中的代码顺序不管怎么重排序，对于结果来说是不变的。
2、volatile 变量规则，对于 volatile 修饰的变量的写的操作， 一定 happen-before 后续对于 volatile 变量的读操作;
3、监视器锁规则（monitor lock rule）：对一个监视器的解锁，happens-before于随后对这个监视器的加锁。
4、传递性规则：如果A happens-before B，且B happens-before C，那么A happens-before C。
5、start 规则：如果线程 A 执行操作 ThreadB.start(),那么线程 A 的 ThreadB.start()操作 happens-before 线程 B 中的任意操作。
6、join 规则：如果线程 A 执行操作 ThreadB.join()并成功返回，那么线程 B 中的任意操作 happens-before 于线程 A 从 ThreadB.join()操作成功返回。

class VolatileExample {
    int a = 0;
    volatile boolean flag = false;

    public void writer() {
        a = 1;           //1
        flag = true;     //2
    }

    public void reader() {
        if (flag) {       //3
            int i = a;    //4
            ...
        }
    }
}

   **假设**线程A执行writer()方法之**后**，线程B执行reader()方法，那么线程B执行4的时候一定能看到线程A写入的值吗？注意，a不是volatile变量。
  答案是**肯定的**。因为根据happens-before规则，我们可以得到如下关系：
  根据**程序顺序规则**，1 happens-before 2；3 happens-before 4。
  根据**volatile规则**，2 happens-before 3。
  根据**传递性规则**，1 happens-before 4。
  因此，综合运用**程序顺序规则**、**volatile规则及传递性规则**，我们可以得到1 happens-before 4，即线程B在执行4的时候一定能看到A写入的值。

3，简单介绍一下volatile关键字的作用 ？

volatile 关键字来保证可见性和禁止指令重排
提供了一种禁止指令重排序的机制和通过内存屏障的机制解决可见性问题。

参考简书：并发编程-（4）-JMM基础（总线锁、缓存锁、MESI缓存一致性协议、CPU 层面的内存屏障）