关于java:JDK成长记14深度好文你能从3个层面分析volatile底层原理么下

上一节咱们根本理解 Volatile 的作用，从 JMM 层面简略剖析了下 volatile 可见性的实现要求。发现 JMM 设定了一些操作要求，在这些要求下，能够保障线程间的可见性。可是具体实现是怎么实现的呢？

然而你要想了解这个实现是比拟难的，之前提到依照三个层面给大家解说。如下图所示：

其实上一节通过 JMM 剖析 volatile 是归于 JVM 层面剖析的一部分而已。

你要想齐全弄清楚 volatile 的可见性和有序性，你还要持续剖析字节码层面的 JVM 指令标记是什么？Hotspot 实现的 JSR 内存屏障是什么意思？最终实现的 C ++ 代码收回的汇编指令是什么？以及硬件层面如何实现可见性和有序性的？

所以这一节咱们来持续钻研其余的局部。首先从最简略的一个例子看起，之后手写出一个 DCL 单例，通过这个例子咱们来真正的弄清楚 java 代码层面到 JVM 层面再到 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;”> 从手写一个 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

下面的输入后果证实了这个是线程平安的单例。

<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 级别的重排序，还有其余的)

<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 dup
9 astore_0
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
35 aload_1
36 athrow
37 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，不是单例了，这就是有序性造成的问题。

如下图所示：

<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 代码 + 字节码层面剖析：字节码乱序了会怎么样？

<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 前缀指令。

<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 公布！