高并发篇_11 volatile底层实现原理

拼搏现实的明天。 2022-10-10 01:57 147阅读 0赞

**田超凡**

**原创博文，仿冒必究，部分素材转载自****每特教育****蚂蚁课堂**

### 1 MESI缓存一致性协议 ###

上文写到，volatile可以保证线程可见性，底层实现机制是基于JMM八大同步规范和汇编lock前缀指令触发底层锁的机制，而实现锁的机制有两种：总线锁和MESI缓存一致性协议，这里就来详细分析MESI缓存一致性协议的定义、组成部分以及如何同JMM八大同步规范结合，从而保证线程可见性的。

**MESI****缓存一致性协议主要由四个部分组成：**

**M-Modify** **修改**

**E-Exclusion** **独享**

**S-Shared** **共享**

**I-Invalid** **无效**

**E** **独享状态：在单核CPU且只有一个线程的情况下，如果当前线程工作内存中的数据和主内存数据保持一致，则当前cpu的状态是：E 独享状态**

**S** **共享状态：在多核CPU多个线程并行的情况下，每个线程的工作内存中的数据都和主内存中的数据保持一致，则每个CPU的状态是：S共享状态**

**M** **修改状态：当某个线程修改了工作内存中的数据，导致当前线程本地内存中的数据和主内存数据不一致，则当前cpu的状态是：M修改状态**

**I** **无效状态：当某个线程修改了工作内存中的数据，并刷新到主内存之后，总线嗅探机制监听到主内存中的数据发生了变化，会强制将其他线程本地内存中的数据设置为I无效状态，此时工作内存被设置为无效状态的线程需要重新读取主内存中的数据到工作内存中**

### 2 volatile不保证原子性的原因 ###

**public class** VolatileThread **extends** Thread \{  
  
    **private static volatile int** *count*;  
  
    **public static void** create()

\{  
        *count*\++;  
    \}  
  
    **public static void** main(String\[\] args)

\{  
        ArrayList threads = **new** ArrayList<>();  
        **for** (**int** i = 0; i < 10; i++) \{  
            Thread tempThread = **new** Thread(() -> \{  
                **for** (**int** j = 0; j < 1000; j++) \{  
                    *create*();  
                \}  
            \});  
            threads.add(tempThread);  
            tempThread.start();  
        \}  
        threads.forEach(thread -> \{  
            **try** \{  
                thread.join();  
            \} **catch** (InterruptedException e) \{  
                e.printStackTrace();  
            \}  
        \});  
        System.***out***.println(*count*);  
    \}  
\}

输出结果count<=10000，说明volatile不能保证线程操作的原子性。

volatile为什么不能保证原子性呢？基于如上代码来分析线程执行过程：

假设现在有2个线程，每个线程都需要对共享变量count执行自增操作，正常情况下应该是执行两次自增操作，结果是2，但是实际执行流程是：

1.  刚开始，主内存中的共享变量count=0(初始值)，线程1和线程2的本地内存中都执行count++
2.  假设线程2先将本地内存中的数据刷新到主内存，此时主内存中的count值发生了变化，变成count=1
3.  基于总线嗅探机制，此时会监听到主内存中的数据发生了变化，那么会强制触发STW，让其他线程本地内存中的数据全部设置为I无效状态(基于JMM八大同步规范和MESI缓存一致性协议)
4.  此时，线程1本地内存中的数据被设置为无效，它需要重新读取主内存中的数据，此时主内存中的数据已经变成了count=1，那么读取到的值就是count=1，线程1本地内存中的数据就是count=1

至此，问题发生，线程1本地内存中的count++操作被丢失了！原本设想每个线程分别执行一次count++，一共执行2次，但是实际情况并非如此。原因是什么呢？这就是因为总线嗅探机制和MESI缓存一致性协议使原本线程1本地内存执行的count++操作被设置为无效，导致线程1需要重新读取主内存中的最新值并更新到本地内存中，此时线程1本地内存原本应执行的count++操作失效了，也就导致线程操作失去了原子性保障。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70][]

### 3 synchronized保证线程可见性的实现原理 ###

synchronized可以保证线程可见性和线程原子性，是保证线程安全最有利的保障，那么synchronized为什么可以保证线程可见性呢？

**synchronized****是重量级锁的实现，线程每次执行synchronized同步方法或同步代码块时都需要获取锁和释放锁**

**synchronized****在每次获取锁时，都会强制清除每个线程本地内存中的值，迫使每个线程重新读取主内存中的最新值并更新到各自的本地内存中**

**synchronized****在每次释放锁时，都会强制将当前线程本地内存中的值刷新到主内存中，从而触发总线嗅探机制，将其他线程本地内存中的值都设置为无效，迫使它们重新从主内存中获取最新的值并更新到各自的本地内存中**

这就是synchronized可以保证线程可见性的实现原理

### 4 重排序基本概念 ###

重排序并没有严格的定义，整体上可以分为两种：

(1) **真重排序**：**编译器、底层硬件（CPU等）出于“优化”的目的，按照某种规则将指令重新排序（尽管有时候看起来像乱序）;**

(2) **伪重排序**：**由于缓存同步顺序等问题，看起来指令被重排序了;**

重排序也是单核时代非常优秀的优化手段，有足够多的措施保证其在单核下的正确性。

在多核时代，如果工作线程之间不共享数据或仅共享不可变数据，重排序也是性能优化的利器。但是，**如果工作线程之间共享了可变数据，由于两种重排序的结果都不是固定的，会导致工作线程似乎表现出了随机行为。**

### 5 重排序的应用-双重校验锁及其缺陷 ###

public class Singleton {     private static  Singleton singleton; 
         public static Singleton getInstance() {         if (singleton == null) {             synchronized (Singleton.class) {                 if (singleton == null) {                     singleton = new Singleton();                 }             }         }         return singleton;     }     public static void main(String[] args) {         Singleton instance1 = Singleton.getInstance();         Singleton instance2 = Singleton.getInstance();         System.out.println(instance1==instance2);     } }

**创建对象过程：**

**（1）分配内存空间**

**（2）初始化对象**

**（3）将内存空间的地址赋值给对象的引用**

**注意：（2）（3）会被处理器优化，发生重排序**

**A线程singleton = new Singleton()发生重排序，将分配的内存空间引用赋值给了静态属性singleton（即singleton != null），而对象还未初始化（即Integer a == null）；**

**B线程此时调用getInstance()方法，因为singleton != null，直接返回singleton。当B线程使用singleton的a属性时就会空指针。**

// 创建 Singleton 对象实例，分配内存

0: new //

// 复制栈顶地址，并再将其压入栈顶

3: dup

// 调用构造器方法，初始化 Singleton  对象

4: invokespecial    // Method "":()V

// 存入局部方法变量表

7: astore\_0

从字节码可以看到创建一个对象实例，可以分为三步：

1.  分配对象内存

: new //

1.  调用构造器方法，执行初始化

invokespecial    // Method "":()V

3.将对象引用赋值给变量。

7: astore\_0

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70 1][]

虚拟机实际运行时，以上指令可能发生重排序。以上代码 2,3 可能发生重排序，但是并不会重排序 1 的顺序。也就是说 1 这个指令都需要先执行，因为 2,3 指令需要依托 1 指令执行结果。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70]: /images/20221005/f12154b50abb4a2184eb2166373c234d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70 1]: /images/20221005/a0f5b8c913d040058ad821198fbecf04.png