提到Java并发编程，逃不掉一个关键"人物"-------->>volatile关键字。

在看过一些并发书籍和大量帖子文章后，我也斗胆提起写下关于volatile的一些理解与心得。

Q1：请你谈谈对Volatile关键字的理解？

1.保证可见性
2.保证有序性，禁止指令重排
3.不保证原子性（需要借助synchronized或者CAS)

初识JMM

Java内存模型(JavaMemoryModel)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量，存储到内存和从内存中读取变量这样的底层细节。

JMM有以下规定：

所有的共享变量都存储于主内存，这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。

线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量

不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存中转来完成。

本地内存和主内存的关系

正是因为这样的机制，才导致了可见性问题的存在，那我们就讨论下可见性的解决方案。

为什么加锁可以解决可见性问题呢？

因为某一个线程进入synchronized代码块前后，线程会获得锁，清空工作内存，从主内存拷贝共享变量最新的值到工作内存成为副本，执行代码，将修改后的副本的值刷新回主内存中，线程释放锁。
而获取不到锁的线程会阻塞等待，所以变量的值肯定一直都是最新的。

什么是内存可见性，volatile怎么保证多个线程之间的可见性的？

所谓可见性，是指当一条线程修改了共享变量的值，新值对于其他线程来说是可以立即得知的。每个线程都有自己独立的工作区间，为了匹配CPU的运行速度，他们不会直接从内存中读取数据，而是将数据拷贝一份到CPU缓存中（即每个线程自己的工作内存），他们之间的相互交互，是通过内存来完成的。
根据JMM内存模型的8大原子操作，每个线程在j将数据操作完stroe回主存之前，会加lock指令来锁定内存区域的缓存（缓存行锁定），根据MESI缓存一致性协议，总线通过侦听器发现数据被修改，会立即让其他线程工作内存中不一致的副本立即失效。等到当前线程将更改后的数据write回主存后，立即执行unlock指令。此时，其他线程再重新读取更新后的数据，再拷贝到自己的工作内存。总线侦听机制会在总线上检测线程的数据，发现有线程做了更改时准备store回主内存时，它就会立刻将其他线程工作内存中的副本置位无效，然后从新到主存获取更新后的值。
除了使用 volatile 关键字来保证内存可见性之外，使用synchronized或Lock锁也能保证变量的内存可见性。只是相比而言使用 volatile关键字开销更小，是轻量级的锁。

什么是MESI（缓存一致性协议）呢？

MESI（缓存一致性协议）

当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

至于是怎么发现数据是否失效呢？

Java中采用总线嗅探机制。

每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

禁止指令重排序

什么是重排序?

为了提高性能，编译器和处理器常常会对既定的代码执行顺序进行指令重排序。

重排序的类型有哪些呢？源码到最终执行会经过哪些重排序呢？

一个好的内存模型实际上会放松对处理器和编译器规则的束缚，也就是说软件技术和硬件技术都为同一个目标，而进行奋斗：在不改变程序执行结果的前提下，尽可能提高执行效率。
JMM对底层尽量减少约束，使其能够发挥自身优势。

因此，在执行程序时，为了提高性能，编译器和处理器常常会对指令进行重排序。
一般重排序可以分为如下三种：

1.，编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序;
2.指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序;
3.内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行的。

as-if-serial

不管怎么重排序，单线程下的执行结果不能被改变。
编译器、runtime和处理器都必须遵守as-if-serial语义。

那Volatile是怎么保证不会被执行重排序的呢？

内存屏障

使用volatile关键字修饰共享变量便可以禁止指令重排序。若用volatile修饰共享变量，在JVM底层volatile是采用“内存屏障”来实现禁止特定类型的处理器重排序。加入volatile关键字时，会多出一个lock前缀指令，lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
它会强制将对缓存的修改操作立即写入主存；
如果是写操作，它会导致其他CPU中对应的缓存行无效。
JMM具备一些先天的有序性，通过Happens-Before原则就可以保证的一定的有序性。
为了实现volatile的内存语义，JMM会限制特定类型的编译器和处理器重排序，JMM会针对编译器制定volatile重排序规则表：

（上图摘自《Java并发编程的艺术》一书）

happens-before规则

如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。

volatile域规则：对一个volatile域的写操作，happens-before于任意线程后续对这个volatile域的读。

volatile能保证可见性和有序性，但是能保证原子性吗？为什么？

volatile关键字不能保证原子性。
a. 当写一个volatile变量时，JMM会把该线程本地内存中的变量强制刷新到主内存中去；
b. 这个写会操作会导致其他线程中的缓存无效。
对于类似i++这样的复合操作，要想保证原子性，只能借助于synchronized、Lock以及并发包下的AtomicInteger的原子操作类。AtomicInteger对基本数据类型的 自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保证这些操作是原子性操作。

volatile的一个应用。

我这里采用一个双重检查单例模式。

volatile与synchronized的区别

1.volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。
2.volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他(互斥)的机制。
3.volatile用于禁止指令重排序：可以解决单例双重检查对象初始化代码执行乱序问题。
4.volatile可以看做是轻量版的synchronized，volatile不保证原子性，但是如果是对一个共享变量进行多个线程的赋值，而没有其他的操作，那么就可以用volatile来代替5.synchronized，因为赋值本身是有原子性的，而volatile又保证了可见性，所以就可以保证线程安全了。

总结

1.volatile修饰符适用于以下场景：某个属性被多个线程共享，其中有一个线程修改了此属性，其他线程可以立即得到修改后的值，比如booleanflag;或者作为触发器，实现轻量级同步。
2.volatile属性的读写操作都是无锁的，它不能替代synchronized，因为它没有提供原子性和互斥性。因为无锁，不需要花费时间在获取锁和释放锁_上，所以说它是低成本的。
3.volatile只能作用于属性，我们用volatile修饰属性，这样compilers就不会对这个属性做指令重排序。
4.volatile提供了可见性，任何一个线程对其的修改将立马对其他线程可见，volatile属性不会被线程缓存，始终从主 存中读取。
5.volatile提供了happens-before保证，对volatile变量v的写入happens-before所有其他线程后续对的读操作。
6.volatile可以使得long和double的赋值是原子的。
7.volatile可以在单例双重检查中实现可见性和禁止指令重排序，从而保证安全性。

资料参考《Java并发编程的艺术》
博客：三太子敖丙