上一节咱们根本理解Volatile的作用，从JMM层面简略剖析了下volatile可见性的实现要求。发现JMM设定了一些操作要求，在这些要求下，能够保障线程间的可见性。可是具体实现是怎么实现的呢？
然而你要想了解这个实现是比拟难的，之前提到依照三个层面给大家解说。如下图所示：
其实上一节通过JMM剖析volatile是归于JVM层面剖析的一部分而已。
你要想齐全弄清楚volatile的可见性和有序性，你还要持续剖析字节码层面的JVM指令标记是什么？Hotspot实现的JSR内存屏障是什么意思？最终实现的C++代码收回的汇编指令是什么？以及硬件层面如何实现可见性和有序性的？
所以这一节咱们来持续钻研其余的局部。首先从最简略的一个例子看起，之后手写出一个DCL单例，通过这个例子咱们来真正的弄清楚java代码层面到JVM层面再到CPU层面的volatile原理。
让咱们开始吧！
从手写一个DCL单例开始剖析volatile
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;"> 从手写一个DCL单例开始剖析volatile</span></h3></div>
在写DCL单例前咱们先简略写一个volatile的例子，从java代码和字节码层面剖析volatile底层原理。代码如下：
public class DCLVolatile { volatile int i = 10;}你能够在IntelliJ中通过jclasslib插件（自行百度装置）能够看到编译后的字节码格局，这个volatile变量int i对应的格局如下：
而通常不加volatile的变量，比方int m 的字节码标识如下所示：
能够看出在java代码层面volatile润饰的变量通过javac动态编译后，变成了带有Access flags 0x0040这个非凡标记的变量，这样之后就能够被JVM辨认进去。这里是常量，如果是动态的instance对象是0x004a，非动态的是0x0042。
手写DCL单例，第一步你须要应该申明一个volatile的实例变量。（前面会将为什么是volatile的，大家不要焦急）。
代码如下：
public class DCLVolatile { private static volatile DCLVolatile instance; //0x004a }所以在这个层面你能够失去如下的一张图：
接着你须要理解一个对象创立的时候的字节码指令，以便于之后剖析指令重排序的问题。代码如下：
public class DCLVolatile { /** * ByteCode:Access Flag 0x004a */ private static volatile DCLVolatile instance; private DCLVolatile(){ } /** * ByteCode: * 0 new #2 <org/mfm/learn/juc/volatiles/DCLVolatile> * 3 dup * 4 invokespecial #3 <org/mfm/learn/juc/volatiles/DCLVolatile.<init>> * 7 astore_0 * 8 aload_0 * 9 areturn * @return */ public static DCLVolatile getInstance() { DCLVolatile instance = new DCLVolatile(); return instance; } 从下面的代码能够看出 DCLVolatile instance = new DCLVolatile();的字节码次要是如下几行：
0 new #2 <org/mfm/learn/juc/volatiles/DCLVolatile> 3 dup 4 invokespecial #3 <org/mfm/learn/juc/volatiles/DCLVolatile.<init>> 7 astore_0如果这几条字节码理论就是JVM指令，具体意思能够查阅官网的JVM指令手册。这里我间接用大白话给大家解释下：
new 必定就是创立一个对象。留神这里只是在堆中调配空间，（叫半初始化）此时instance = null，并没有指向堆空间
dup其实就是入操作数栈一个变量instance。
invokespecial其实执行了初始化操作，应用instance援用指向堆调配的空间。
astore_0将一个数值从操作数栈存储到局部变量表。
JVM指令 JVM除了对底层硬件内存模型进行了形象，对执行CPU指令同样进行了形象，这样能够更好地做到跨平台性。 既然JVM将底层CPU执行指令的过程进行了形象，这里咱们不去细讲JVM，形象的内容大抵能够详情为如下一句话： 执行class文件的时候是通过在内存构造，一套简单的入栈出栈机制执行class中的各个JVM指令，在执行指令层面，它有本人一套独特的JVM指令集，而这写JVM指令就是来源于咱们写好的Java代码。
下面过程如下图所示：
你能够接着欠缺DCL单例最终为：
public class DCLVolatile { private static volatile DCLVolatile instance; private DCLVolatile(){ } public static DCLVolatile getInstance() if( instance == null){ synchronized (DCLVolatile.class){ if(instance == null){ instance = new DCLVolatile(); } } } return instance; } } 下面这段代码，double判断+ synchronized+valotile这就是典型的 DCL单例，线程平安的。能够保障多个线程获取instance是线程平安，且是同一个对象。synchronized是为了保障多线程同时创建对象的这个操作的安全性，double判断+volotile是为了保障这个创立操作的可见性和有序性。
下面的输入后果证实了这个是线程平安的单例。
你能够测试下：
public static void main(String[] args) { new Thread(()->{ DCLVolatile instance = DCLVolatile.getInstance(); System.out.println(instance); }).start(); new Thread(()->{ DCLVolatile instance = DCLVolatile.getInstance(); System.out.println(instance); }).start(); }输入如下：
org.mfm.learn.juc.volatiles.DCLVolatile@71219ecd
org.mfm.learn.juc.volatiles.DCLVolatile@71219ecd
下面的输入后果证实了这个是线程平安的单例。
Java代码+字节码层面剖析：为什么会乱序？
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;"> Java代码+字节码层面剖析：为什么会乱序？</span></h3></div>
volatile的可见性体现:
instance == null是volatile的读，instance = new DCLVolatile();是volatile的写，线程之间是可见的。
volatile的有序性体现：
要想晓得为什么它保障了有序性，须要理解为什么会有乱序、DCL中，字节码乱序了会怎么样。
一个一个来看下，首先是为什么会乱序？
所有的编程语言最终会变成01的机器码，让CPU硬件能够意识。你写的java代码也一样，java代码到CPU执行指令的过程如下图所示：
图中标红色的就是可能指令重排的中央， 因为了进步并发度和指令执行速度，CPU或者编译器会进行指令的优化和重排。然而咱们有时候不心愿指令重排，打乱程序可能造成一些有序性问题。这时候就须要一些办法来管制和实现这一点了。Java中volatile关键字就是一种办法。
书曰重排序：是指编译器和处理器为了优化程序性能而对指令序列进行从新排序的一种伎俩。 在单线程程序中，对存在管制依赖的操作重排序，不会扭转执行后果（这也是as-if-serial语义容许对存在管制依赖的操作做重排序的起因）；但在多线程程序中，对存在管制依赖的操作重排序，可能会改变程序的执行后果。 其实能够了解为，就是cpu为了优化代码的执行效率，它不会按程序执行代码，会打乱代码的执行程序，前提是不影响单线程程序执行的后果。(当然了，只思考cpu级别的重排序，还有其余的)
Java代码+字节码层面剖析：字节码乱序了会怎么样？
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;">Java代码+字节码层面剖析：字节码乱序了会怎么样？</span></h3></div>
理解了为什么会乱序后，接着咱们看下字节码乱序了会怎么样？
回到下面的DCL单例的代码中，下面你理解了创立一个对象的字节码后，你须要剖析下欠缺后的getInstance办法字节码,如下：
0 getstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance>3 ifnonnull 37 (+34)6 ldc #8 <org/mfm/learn/juc/volatiles/DCLVolatile>8 dup9 astore_010 monitorenter11 getstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance>14 ifnonnull 27 (+13)17 new #8 <org/mfm/learn/juc/volatiles/DCLVolatile>20 dup21 invokespecial #9 <org/mfm/learn/juc/volatiles/DCLVolatile.<init>>24 putstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance>27 aload_028 monitorexit29 goto 37 (+8)32 astore_133 aload_034 monitorexit35 aload_136 athrow37 getstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance>40 areturn你能够抓大放小，只关怀创建对象的字节码：
10 monitorenter 11 getstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance> 14 ifnonnull 27 (+13) 17 new #8 <org/mfm/learn/juc/volatiles/DCLVolatile> 20 dup 21 invokespecial #9 <org/mfm/learn/juc/volatiles/DCLVolatile.<init>> 24 putstatic #7 <org/mfm/learn/juc/volatiles/DCLVolatile.instance> 27 aload_0 28 monitorexit 29 goto 37 (+8) 32 astore_1 33 aload_0 34 monitorexit monitorenter是synchronized的指令，当初能够先疏忽，前面咱们讲Synchronized的时候会具体解说。
创建对象的字节外围还是3步
1） 调配空间，半初始化 new
2） 之后进行赋值操作 invokespecial
3） 再之后进行援用指向对象 astore_1
大家能够设想下，如果两个线程同时调用getInstance办法。
线程1获取到sychronized的锁，第一次创立instance的时候，如果2）3）步的指令产生了重排序,如果没有volatile禁止重排序的话。如下代码创立的instance就可能不是同一个对象了。
public static DCLVolatile getInstance() { if( instance == null){ synchronized (DCLVolatile.class){ if(instance == null){ instance = new DCLVolatile(); } } } return instance; }线程2获取到了instance可能是一个半初始化的对象，也就是null，间接应用的话必定会有问题，就会创立一个新的instance，不是单例了，这就是有序性造成的问题。
如下图所示：
再次从JVM层面剖析：JVM指令怎么执行的？
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;">再次从JVM层面剖析：JVM指令怎么执行的？</span></h3></div>
通过下面DCL单例的例子，置信你曾经对java代码到字节码的volatile的作用有了进一步理解，具体怎么实现可见性和有序性的基本原理呢？这还是在JVM层面实现的，所以上面，咱们接着进入JVM层面来剖析。
接下来你会明确下面的JVM指令具体如何执行，由谁执行，又遵循哪些标准和规定？
让咱们来一一看下。
JVM指令具体如何执行
JVM首先就是通过类加载器加载class到JVM内存区域，之后又通过执行引擎来执行JVM指令。
不同的过JDK版本有不同的的JVM实现。有耳熟能详的HotSpot,有淘宝本人的JVM实现，还有J9、OpenJDK等其余的JVM实现……
但JDK1.8后，最常见的就是HotSpot的JVM的实现。它是一套次要以C++代码为主实现的JVM虚拟机。咱们就以HotSpot举例。
上述过程如下图所示：
那么，编译好的字节码文件被JVM通过类加载器加载到内存构造之后，会被HotSpot来进行调度和执行对应的JVM指令。
怎么执行的呢？
HotSpot是通过外部的解释器、JIT动静编译器(含Client（C1）编译器、Server（C2）编译器）来执行JVM指令。
如下图所示：
HotSpot是JVM标准的一个实现，它遵循了很多JVM虚拟机标准和JSR标准。
什么是标准？ 标准能够打个比喻，标准就好比插座的插槽、插头，它们定义了2孔和3孔的间距等等。所有的厂家都得遵循这个标准，能力让所有的插头插入插板，只有这个插头符合规范，能够是任何牌子，也就是任何厂商的实现。而Java畛域有很多标准，个别是由一个公共组织JCP来定义的，定义的标准是JSR-XXX。这个其实也有点像java中的接口和实现类的感觉，说白了就是具体事物的形象定义。
JVM的虚拟机标准定义了一些规定，和可见性和有序性无关的规定是happen-before 规定：要求8种状况不能乱序执行。（能够自行百度）其中有一条很重要的规定就是：
volatile变量规定：对一个变量的写操作后行产生于前面对这个变量的读操作。volatile变量写，再是读，必须保障是先写，再读。
Java中，其中有一个JSR标准，形容了内存屏障相干标准：
1) LoadLoad屏障：对于这样的语句Load1; LoadLoad; Load2，在Load2及后续读取操作要读取的数据被拜访前，保障Load1要读取的数据被读取结束。
2) StoreStore屏障：对于这样的语句Store1; StoreStore; Store2，在Store2及后续写入操作执行前，保障Store1的写入操作对其它处理器可见。
3) LoadStore屏障：对于这样的语句Load1; LoadStore; Store2，在Store2及后续写入操作被刷出前，保障Load1要读取的数据被读取结束。
4) StoreLoad屏障：对于这样的语句Store1; StoreLoad; Load2，在Load2及后续所有读取操作执行前，保障Store1的写入对所有处理器可见。
网上有很多博客解说volatile的原理，外面写的乌七八糟的，让人看到头晕眼花。搞不清楚内存屏障，JVM指令各种关系。真心让人看到有些累。4种内存屏障其实是标准定义而已，这一点大家肯定要搞明确。
在volatile的JVM实现中，是这么应用屏障的。
下面四种内存屏障联合happen-before准则，其实就是一句话：
比方LoadLoadBarrier,就是示意下面一条Load指令（读指令），上面一条Load指令，不能重排序。
那你必定就晓得了StoreLoadBarrier屏障是什么意思。就是示意下面一条Store指令（写指令），上面一条Load指令，不能重排序。
留神，下面这些标准只是定义，相似于接口，具体怎么实现就得看HotSpot的C++代码了。 如下图所示：
Java代码+字节码层面剖析：字节码乱序了会怎么样？
再次从JVM层面剖析：HotSpot到底怎么禁止重排序的呢？
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;">再次从JVM层面剖析：HotSpot到底怎么禁止重排序的呢？</span></h3></div>
理论是通过一些C++的fense办法，生成一些汇编语言，最终转换为机器码，执行CPU指令。所谓的内存屏障理论是一条非凡的指令，要求不能换程序。
如下图所示：
这里咱们不去深刻HotSopt源码，在外面也看不出来发送给CPU的指令，须要通过工具能力看进去。你能够通过JIT生成代码反汇编工具：（HSDIS），看进去发送给CPU的汇编代码指令，留神，汇编代码是给人看到，理论CPU还是辨认0/1的机器码,来执行Cpu指令的。
通过HSDIS工具，能够执行失去如下JIT反汇编语言：!
好了到了这里，根本JVM这一层面的volatile原理，就给大家剖析分明了。能够看到，volatile最终会转换为一条CPU的lock前缀指令。
从CPU层面剖析：volatile底层原理
<div class="output_wrapper" id="output_wrapper_id" style="width:fit-content;font-size: 16px; color: rgb(62, 62, 62); line-height: 1.6; word-spacing: 0px; letter-spacing: 0px; font-family: 'Helvetica Neue', Helvetica, 'Hiragino Sans GB', 'Microsoft YaHei', Arial, sans-serif;"><h3 id="hdddd" style="width:fit-content;line-height: inherit; margin: 1.5em 0px; font-weight: bold; font-size: 1.3em; margin-bottom: 2em; margin-right: 5px; padding: 8px 15px; letter-spacing: 2px; background-image: linear-gradient(to right bottom, rgb(43,48,70), rgb(43,48,70)); background-color: rgb(63, 81, 181); color: rgb(255, 255, 255); border-left: 10px solid rgb(255,204,0); border-radius: 5px; text-shadow: rgb(102, 102, 102) 1px 1px 1px; box-shadow: rgb(102, 102, 102) 1px 1px 2px;"><span style="font-size: inherit; color: inherit; line-height: inherit; margin: 0px; padding: 0px;">从CPU层面剖析：volatile底层原理</span></h3></div>
JVM不同的实现，对发送给CPU的指令理论都一些差别，而且在历史上，CPU实现形式也可能不同，次要有如下三种机制：
前一个大节提到了lock前缀指令，是最常提到的的形式，实用于所有CPU，所有CPU都反对这个指令。lock前缀指令的之前是锁总线这个硬件的传输，因为性能太差，前面优化成了总线嗅探机制+MESI协定。这样益处是能够跨平台，没有CPU硬件的各种限度。
据我所知，起码OpenJDK和HotSpot是应用lock这种形式的这样的（这个考据起来比拟艰难，如果这里写的不对，欢送各位大神指出！）
除了lock前缀指令，也能够通过一些fence指令做到可见性和有序性的保障，当然耳熟能详的通过MESI协定也能够做到。
上面咱们别离来看下这3种机制。
在理解之前，这里须要回顾下计算机的组成和CPU的硬件缓存构造，之前也提到过，CPU的硬件缓存构造理论是能够和JMM内存逻辑模型对应上的。
咱们先来看下，计算机的组成如下图：
再来看下CPU外围组件图：
有了下面的2张图，你就能够晓得，理论CPU执行的是通过共享的内存:高速缓存、RAM内存、L3，CPU外部线程公有的内存L1、L2缓存，通过总线从逐层将缓存读入每一级缓存。如下流程所示：
RAM内存->高速缓存（L4个别位于总线）->L3级缓存（CPU共享）->L2级缓存（CPU外部公有）->L1级缓存（CPU外部公有）。
这样当java中多个线程执行的时候，理论是交给CPU的每个寄存器执行每一个线程。一套寄存器+程序计数器能够执行一个线程，平时咱们说的4核8线程，理论指的是8个寄存器。所以Java多线程执行的逻辑对应CPU组件如下图所示：
当你有了下面几张图的概念，就能够了解指令在不同CPU和缓存间接作用。
CPU硬件实现可见性和有序性3种机制
零碎fence类指令
X86 CPU的能够通过fence类指令实现相似内存屏障的操作：
a) sfence:在sfence指令前的写操作当必须在sfence指令后的写操作前实现。
b) lfence：在lfence指令前的读操作当必须在lfence指令后的读操作前实现。
c) mfence：在mfence指令前的读写操作当必须在mfence指令后的读写操作前实现。
这种机制不太实用于所有CPU，所以目前不怎么采纳了。
- locc前缀指令
IntelCPU lock前缀汇编指令保障有序性。Lock前缀指令简直实用于所有CPU。
它的原子指令，如X86的Intel上，local addl XX指令是一个Full Barraier,会锁住内存子系统来确保执行程序，甚至跨多个CPU。SoftwareLocks通常应用了内存屏障或者原子指令，来实现变量可见性和放弃程序程序。
下面看上去有点难懂，大家这么了解就行：
这个指令最早的时候，其实人家用的是一个叫做总线加锁机制。目前应该曾经没有人来用了，他大略的意思是说，某个cpu如果要读一个数据，会通过一个总线，对这个数据加一个锁，其余的cpu就没法通过总线去读和写这个数据了，只有当这个cpu批改完了当前，其余cpu能够读到最新的数据。
然而因为这样多线程下会造成串行化，性能低，起初联合lock前缀指令+总线嗅探机制+广为人知的MESI协定进行了优化。（这里如果说的不精确，大家能够提出来）。
所以咱们来具体钻研下MESI到底通过哪些指令来实现，MESI的机制流程有时如何的。
MESI协定
缓存一致性协定有很多，比方除了MESI之外的缓存一致性协定还有MSI、MOSI、Synapse Firefly Dragon等等。
这里用的最多的就是MESI这个协定。
什么是MESI协定？
MESI协定规定：对一个共享变量的读操作能够是多个处理器并发执行的，然而如果是对一个共享变量的写操作，只有一个处理器能够执行，其实也会通过排他锁的机制保障就一个处理器能写。
要想了解这个协定须要具备两个前提：
1) 相熟MESI的4个指令
2) 相熟CUP构造和缓存行的数据结构
首先先来理解下缓存行的概念：
缓存行默认是64字节Byte,（程序局部性原理，当读取一条数据的时候，也会读取它左近的元素，很大可能会用到）通过工业界实际，能够充分发挥总线CPU针脚等一次性读取数据的能力，提高效率。
个别状况，缓存行的根本单位是一个64字节的数据，用于在L1、L2、L3、高速缓存Cache间传输数据。
处理器高速缓存的底层数据结构理论是一个拉链散列表的构造，就是有很多个bucket，每个bucket挂了很多的cache entry，每个cache entry由三个局部组成：tag、cache line和flag，其中的cache line就是缓存的数据。
tag指向了这个缓存数据在主内存中的数据的地址，flag标识了缓存行的状态，另外要留神的一点是，cache line中能够蕴含多个变量的值。
接着再来理解下MESI的4个指令：
MESI协定规定了一组音讯，就说各个处理器在操作内存数据的时候，都会往总线发送音讯，而且各个处理器还会不停的从总线嗅探最新的音讯，通过这个总线的消息传递来保障各个处理器的合作。
之前说过那个cache entry的flag代表了缓存数据的状态，MESI协定中划分为：
（1）invalid：有效的，标记为I，这个意思就是以后cache entry有效，外面的数据不能应用
（2）shared：共享的，标记为S，这个意思是以后cache entry无效，而且外面的数据在各个处理器中都有各自的正本，然而这些正本的值跟主内存的值是一样的，各个处理器就是并发的在读而已
（3）exclusive：独占的，标记为E，这个意思就是以后处理器对这个数据独占了，只有他能够有这个正本，其余的处理器都不能蕴含这个正本
（4）modified：批改过的，标记为M，只能有一个处理器对共享数据更新，所以只有更新数据的处理器的cache entry，才是exclusive状态，表明以后线程更新了这个数据，这个正本的数据跟主内存是不一样的
到底底层是如何实现这套MESI的机制，通过哪些指令，这个指令干了什么事件，能力保障说，我方才说的那种成果，批改本地缓存，立马刷主存，其余cpu本地缓存立马工期，从新从主存加载。
上面来具体的图解MESI协定的工作原理：
读I->S
处理器0读取某个变量的数据时，首先会依据index、tag和offset从高速缓存的拉链散列表读取数据，如果发现状态为I，也就是有效的，此时就会发送read音讯到总线
接着主内存会返回对应的数据给处理器0，处理器0就会把数据放到高速缓存里，同时cache entry的flag状态是S。如下图所示：
CPU1:S->I->I-ack
在处理器0对一个数据进行更新的时候，如果数据状态是S，则此时就须要发送一个invalidate音讯到总线，尝试让其余的处理器的高速缓存的cache entry全副变为I，以取得数据的独占锁。
其余的处理器1会从总线嗅探到invalidate音讯，此时就会把本人的cache entry设置为I，也就是过期掉本人本地的缓存，而后就是返回invalidate ack音讯到总线，传递回处理器0，处理器0必须收到所有处理器返回的ack音讯
CPU0:S->I-ack->E->M
接着处理器0就会将cache entry先设置为E，独占这条数据，在独占期间，别的处理器就不能批改数据了，因为别的处理器此时收回invalidate音讯，这个处理器0是不会返回invalidate ack音讯的，除非他先批改完再说
接着处理器0就是批改这条数据，接着将数据设置为M，也有可能是把数据此时强制写回到主内存中，具体看底层硬件实现
而后其余处理器此时这条数据的状态都是I了，那如果要读的话，全副都须要从新发送read音讯，从主内存（或者是其余处理器）来加载，这个具体怎么实现要看底层的硬件了，都有可能的。
上述过程如下图所示：
这套机制其实就是缓存一致性在硬件缓存模型下的残缺的执行原理。
小结
到这里咱们从三个层面，Java代码和字节码->JVM层->CPU硬件原理层面,分析了Volatile底层原理，置信大家对它的可见性、有序性粗浅的了解。
这一节波及的常识特地多，也特地烧脑，大家了解了它的原理之后，更重要的是记住它的应用场景。我给大家总结如下：
原理：
一句话简略概括volatile的原理：就是刷新主内存，强制过期其余线程的工作内存。你能够在不同层面解释：
在java代码层面
场景：
1、 多个线程对同一个变量有读有写的时候
2、 多个线程须要保障有序性和可见性的时候
除了DCL单例，还有线程的优雅敞开这些场景，大家能够在评论去发表本人遇见过的场景。
本文由博客一文多发平台 OpenWrite 公布！