volatile 实现原理

引言

我们要知道并发编程带来的三个主要问题就是,并发编程的可见性，原子性与有序性问题
在多线程并发编程中 synchronized 和 Volatile 都扮演着重要的角色，Volatile 是轻量级的 synchronized，它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。
它在某些情况下比 synchronized 的开销更小，本文将深入分析在硬件层面上 Inter 处理器是如何实现 Volatile 的，通过深入分析能帮助我们正确的使用 Volatile 变量。

操作系统语义

计算机在运行程序时，每条指令都是在 CPU 中执行的，在执行过程中势必会涉及到数据的读写。我们知道程序运行的数据是存储在主存中，这时就会有一个问题，读写主存中的数据没有 CPU 中执行指令的速度快，如果任何的交互都需要与主存打交道则会大大影响效率，所以就有了 CPU 高速缓存。CPU高速缓存为某个CPU独有，只与在该CPU运行的线程有关

有了 CPU 高速缓存虽然解决了效率问题，但是它会带来一个新的问题：数据一致性。在程序运行中，会将运行所需要的数据复制一份到 CPU 高速缓存中，在进行运算时 CPU 不再也主存打交道，而是直接从高速缓存中读写数据，只有当运行结束后，才会将数据刷新到主存中。举一个简单的例子：

解决缓存一致性方案有三种：

1、通过在总线加 LOCK# 锁的方式,
LOCK# 锁 存在一个问题，它是采用一种独占的方式来实现的，即总线加 LOCK# 锁的话，只能有一个 CPU 能够运行，其他 CPU 都得阻塞，效率较为低下

2、通过缓存一致性协议
缓存一致性协议（MESI 协议），它确保每个缓存中使用的共享变量的副本是一致的。其核心思想如下：当某个 CPU 在写数据时，如果发现操作的变量是共享变量，则会通知其他 CPU 告知该变量的缓存行是无效的，因此其他 CPU 在读取该变量时，发现其无效会重新从主存中加载数据。

3、缓存锁
目前新的 CPU ，增加了【缓存锁】来保证原子性

volatile内存语义

volatile是Java虚拟机提供的轻量级的同步机制。volatile关键字有如下两个作用。
保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改 了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。(注意是立即可见,不是可见,经常听到其他人说，因为没有volatile修饰的共享变量刷新到主内存的时机不同，这个后续分析到mesi协议的时候，会在补充)。

Volatile 的官方定义

Java 语言规范第三版中对 volatile 的定义如下： java 编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java 语言提供了 volatile，在某些情况下比锁更加方便。如果一个字段被声明成 volatile，java 线程内存模型确保所有线程看到这个变量的值是一致的。

为什么要使用 Volatile

Volatile 变量修饰符如果使用恰当的话，它比 synchronized 的使用和执行成本会更低，因为它不会引起线程上下文的切换和调度。

volatile的可见性

关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总数立即 可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中

示例

package threadtest.volatiles;

public class volatileTest {
     volatile boolean flag = true;

    public void updateFlag(){
        System.err.println(Thread.currentThread().getName()+"更改flag共享变量开始"+flag);
        this.flag = false;
        System.err.println(Thread.currentThread().getName()+"更改flag共享变量后"+flag);
    }

    public void whileMethod(){
        while (flag){
            System.out.println(Thread.currentThread().getName()+"空转开始"+flag);
            //空转
        }
        System.err.println(Thread.currentThread().getName()+"空转结束"+flag);
    }

    public static void main(String[] args) throws InterruptedException {
        volatileTest volatileTest = new volatileTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                volatileTest.whileMethod();
            }
        }).start();

        Thread.sleep(1000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                volatileTest.updateFlag();
            }
        }).start();
    }
}

线程改变flag立马可以感知到

volatile无法保证原子性

代码示例

package threadtest.volatiles;

public class VolatileTest2 {
    
    private volatile int count = 1;
    
    public void add(){
        count++;
        System.out.println(count);
        
    }

    
}

在并发场景下，i变量的任何改变都会立马反应到其他线程中，但是如此存在多条线程 同时调用increase()方法的话，就会出现线程安全问题，毕竟i++;操作并不具备原子性，该 操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线 程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程 一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于 increase方法必须使用synchronized修饰，以便保证线程安全，需要注意的是一旦使用 synchronized修饰方法后，由于synchronized本身也具备与volatile相同的特性，即可见 性，因此在这样种情况下就完全可以省去volatile修饰变量，

volatile的有序性

有序性：即程序执行的顺序按照代码的先后顺序执行。
在 Java 内存模型中，为了效率是允许编译器和处理器对指令进行重排序，当然重排序它不会影响单线程的运行结果，但是对多线程会有影响。
Java 提供 volatile 来保证一定的有序性。最著名的例子就是单例模式里面的 DCL（双重检查锁）。

通过上边的示例我们知道volitale主要做的事情就是

保证可见性、不保证原子性
禁止指令重排序

在执行程序时为了提高性能，编译器和处理器通常会对指令做重排序

编译器重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
处理器重排序。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。

指令重排序对单线程没有什么影响，他不会影响程序的运行结果，但是会影响多线程的正确性。既然指令重排序会影响到多线程执行的正确性，那么我们就需要禁止重排序

我们先看另一个原则 happens-before：该原则保证了程序的“有序性”，它规定如果两个操作的执行顺序无法从 happens-before 原则中推到出来，那么他们就不能保证有序性，可以随意进行重排序

happens-before 原则
只靠sychronized和volatile关键字来保证原子性、可见性以及有序性，那么编写并发 程序可能会显得十分麻烦，幸运的是，从JDK 5开始，Java使用新的JSR-133内存模型，提 供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题，它是 判断数据是否存在竞争、线程是否安全的依据，happens-before 原则内容如下

1. 程序顺序原则，即在一个线程内必须保证语义串行性，也就是说按照代码顺序执 行。
2. 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是 说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个 锁)。
3. volatile规则 volatile变量的写，先发生于读，这保证了volatile变量的可见性，简 单的理解就是，volatile变量在每次被线程访问时，都强迫从主内存中读该变量的 值，而当该变量发生变化时，又会强迫将最新的值刷新到主内存，任何时刻，不同的 线程总是能够看到该变量的最新值。
4. 线程启动规则 线程的start()方法先于它的每一个动作，即如果线程A在执行线程B 的start方法之前修改了共享变量的值，那么当线程B执行start方法时，线程A对共享 变量的修改对线程B可见
5. 传递性 A先于B ，B先于C 那么A必然先于C
6. 线程终止规则 线程的所有操作先于线程的终结，Thread.join()方法的作用是等待 当前执行的线程终止。假设在线程B终止之前，修改了共享变量，线程A从线程B的 join方法成功返回后，线程B对共享变量的修改将对线程A可见。
7. 线程中断规则 对线程 interrupt()方法的调用先行发生于被中断线程的代码检测到 中断事件的发生，可以通过Thread.interrupted()方法检测线程是否中断。
8. 对象终结规则对象的构造函数执行，结束先于finalize()方法

共享变量

在多个线程之间能够被共享的变量被称为共享变量。共享变量包括所有的实例变量，静态变量和数组元素。他们都被存放在堆内存中，Volatile 只作用于共享变量。

内存屏障 Memory Barriers

是一组处理器指令，用于实现对内存操作的顺序限制。

内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执 行顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于 编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉 编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插 入内存屏障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用 是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。 总之，volatile变量正是通过内存屏障实现其在内存中的语义，即可见性和禁止重排优化
下图是JMM针对编译器制定的volatile重排序规则表。

volitale的实现原理

那么 Volatile 是如何来保证可见性的呢？在 x86 处理器下通过工具获取 JIT 编译器生成的汇编指令来看看对 Volatile 进行写操作 CPU 会做什么事情。
Java 代码：
instance = new Singleton();//instance 是 volatile 变量
汇编代码：
0x01a3de1d: movb $0x0,0x1104800(%esi);
0x01a3de24: lock addl $0x0,(%esp);
有 volatile 变量修饰的共享变量进行写操作的时候会多第二行汇编代码，通过查 IA-32 架构软件开发者手册可知，lock 前缀的指令在多核处理器下会引发了两件事情。
. *将当前处理器缓存行的数据会写回到系统内存。
. * 这个写回内存的操作会引起在其他 CPU 里缓存了该内存地址的数据无效。

处理器为了提高处理速度，不直接和内存进行通讯，而是先将系统内存的数据读到内部缓存（L1,L2 或其他）后再进行操作，但操作完之后不知道何时会写到内存，如果对声明了 Volatile 变量进行写操作，JVM 就会向处理器发送一条 Lock 前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题，所以在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读到处理器缓存里。

Lock 前缀指令会引起处理器缓存回写到内存。Lock 前缀指令导致在执行指令期间，声言处理器的 LOCK# 信号。在多处理器环境中，LOCK# 信号确保在声言该信号期间，处理器可以独占使用任何共享内存。（因为它会锁住总线，导致其他 CPU 不能访问总线，不能访问总线就意味着不能访问系统内存），但是在最近的处理器里，LOCK＃信号一般不锁总线，而是锁缓存，毕竟锁总线开销比较大。在 8.1.4 章节有详细说明锁定操作对处理器缓存的影响，对于 Intel486 和 Pentium 处理器，在锁操作时，总是在总线上声言 LOCK#信号。但在 P6 和最近的处理器中，如果访问的内存区域已经缓存在处理器内部，则不会声言 LOCK#信号。相反地，它会锁定这块内存区域的缓存并回写到内存，并使用缓存一致性机制来确保修改的原子性，此操作被称为“缓存锁定”，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。

一个处理器的缓存回写到内存会导致其他处理器的缓存无效。IA-32 处理器和 Intel 64 处理器使用 MESI（修改，独占，共享，无效）控制协议去维护内部缓存和其他处理器缓存的一致性。在多核处理器系统中进行操作的时候，IA-32 和 Intel 64 处理器能嗅探其他处理器访问系统内存和它们的内部缓存。它们使用嗅探技术保证它的内部缓存，系统内存和其他处理器的缓存的数据在总线上保持一致。例如在 Pentium 和 P6 family 处理器中，如果通过嗅探一个处理器来检测其他处理器打算写内存地址，而这个地址当前处理共享状态，那么正在嗅探的处理器将无效它的缓存行，在下次访问相同内存地址时，强制执行缓存行填充。

缓冲行 Cache line

缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线，需要使用多个主内存读周期

常用到的一些原子操作jvm层面

32位操作系统中除long和double之外的基本类型的赋值操作
64位操作系统中所有的基本类型
加锁：Lock接口 ，synchronized关键字
CAS机制
Atomic operations 不可中断的一个或一系列操作。

cpu层面原子操作

缓存行填充:cache line fill,当处理器识别到从内存中读取操作数是可缓存的，处理器读取整个缓存行到适当的缓存（L1，L2，L3 的或所有）
总线锁
锁缓存

总线锁

总线锁：就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。

总线锁：总线锁保证了原子性，通过lock锁住总线bus，使当前CPU独享内存空间。但是此时其他CPU都不能访问内存其他地址，效率低。

缓存锁

缓存锁：所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK#信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行数据时，会使缓存行无效。

缓存锁：MESI协议。有些无法被缓存或跨域多个缓存行的数据，依然需要使用总线锁，现代CPU的数据一致性实现 = MESI + 总线锁 共同实现

Modified：修改，当前缓存行的数据已被修改，但是没有被写回到主存中。

Exclusive：独享，当前缓存行与主存数据一致，该数据只存在一个CPU中，可以自由读写，而不需要通知其他CPU。

Shared：共享，当前缓存行与主存数据一致，该数据在其他CPU中也存在，不能随意修改，需要先广播通知其他CPU，将其他CPU中的数据标记为Invalid失效状态，才能修改。

Invalid:失效，当前缓存行数据已失效。