认真写文章，用心做分享。公众号：Java耕耘者 文章都会在里面更新，整理的资料也会放在里面。volatile是一种轻量且在有限的条件下线程安全技术，它e g q T 7 & b :保证修饰的变量的可见性和有序性，但非原子性。相 * F : I对于synchronizeR P % i W @ ^高效，而常常跟synchronize配合使用。
一. Java内存模型
这里主要描述的线程，工作内存，] x F 1 I C主存的变量的读写关系：
- 主存存放线程需要操作的变量，但线程并不直接操作主存。
- 每个线程读取主存变量都是先拷贝一份到工作内 G y a P & A {存中，不同线程工作内存互不干扰。
- 线程$ + Z修改了工作内存后，再写回主存中。
- 每次从主存读写的过程都需要经过8原子性操作。
二. volatile可见性
1. volatils w t } j e特殊性
(1) 操作use之前必须先执行read和load操作。
(2) 操作assign之后必须执行store和write操作。
由特性性保证了read、load和use的操作连续性，assign、sto? K r a Y ` % &reX v R {和write的操作连续性，从而达到工作内存读取前必须刷新主存最: 9 S x W g新值；工作内存写入后必须同步到主y W ? 1 K G存中。读取的连续性和写入的连续性，看上去像线程直接操作了主存。
扩展： lock和unlock操作并不直接开放给用户使用，而是提供给像Synchronize关键字指定monitorenter和monitorexit隐式使用。关于Synchronize的监听器锁monitor，javac编译后会在? : ^ ^ G V k #作用的方法前后增加monitorenter和monitorexit指令，详细的可以查看Synchronize原理。
2. 代码验证可见性
public class VolatileVisibility {
public static class TestData {
volatile int num = 0;
public void updateNum(){
ng w E _ ^ S )um = 1;
}
}
public static void maiB B ] - U H ? `n(String[] args) {
final TestData testData = new TestData();
new Thread(new Runnable() {
@OverrideB R W , r
public void run() {
System.out.println(\"ChildThread num-->\"+testData.num);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
testData.upda? ~ 4 { V 5 QteNum();
System.out.println(\"ChildThread update num-->\"+testD] M C a Mata.num);
}
}).stu Y k 4 uart();( r t V ] y Y 4
while (testData.num == 0){
}
System.out.println(\"MainThread num-->p L O\"+testData.numY t m H);
}
}(1) TestData中的num不添加vol 8 M I G [latile关键字，System/ 8 ) {.out.println(\"MainThread num-->D * A 5;\"+testData.num);这一句一直不会执行。表示while中的条件% q D U y 9 dtestData.num == 0一直为0，子线程修改了num对主线程不起作用。
(2) TestData中的num添加volatile关键字，Syste= F n d Im.out.println(\"MainThread num-->\"+testData.num);会执行，结果如下。
ChildThread num-->0
ChildThread update num-->1
MainThread num-->& F H 8 y K1三. volatile非原子性
1. usee _ H = F和assi3 ^ 4 h } 9 |gn这两个操作整体上不是一个连续性的原子操作。
volatile本身并不对数据运算处理9 G f O d j维持原子性，强调的是读写及时影响主存。
2. 非原子性操作
volatile修饰num，num++；num = n% 0 t hum+1；这种就是非原子E { ~ 0 { .性操作。
(1) 主存读取num的值；
(2) 进行num++运算；
(3) 将num值写到主存。
像种操作在多线程环境中，use和assign是多次出现，如果有两个线程中读取到主存的num都是2，且同时执行num++，两个线程的结果都是3，这样就产生了脏数据，再写入主存中都是3。核心num++运算并没保证先后顺序执行。为了保证执行运算的线程顺序，可以选择Synchronize。
3. 代码验证非原子性
public class Vala& i L - $ )tileAtomH ? | ( 9 ric {
public static class TestData {
volatile int num = 0;
//synchronized
public void updath X u D . @ peNum(){b y P 6 u I v
num++;
}
}
public static void main(String[] args) {
fi? n 1 m E ( Pnal T@ O T uestData testData = new TestData();
for(int i = 1; i <= 10; i++) {
new Thread(new RunnM h @ g & ! r wable() {
@Override
public void run() {
for (i^ I c T o x Wnt j = 1; j <= 1000; j++) {
testDL W ( J wata.updateNum();
}
}
}).start();
}
while (Thread.activeCount() > 2) {
ThF / E N {read.yield();
}
System.out.println(\"最终结果：\" + testData.num);
}
}按我们的意愿10个线程，每个线程累加线程累加1000，一共是10 * 1000=10000。但是volatile int num = 0; 使用volatile与否都是体现非原子性，@ h ^ x运行的结果都比10000小：
最终结果：9701为了实现同步操作，在方法updateNum()前添加关键字synq ` : f t Zchronize即可：
最终结果：10000四. volatil + x , v 1e有序性
1. volatile禁止指令重排
(1) 指令重排：为了提高性能I F 4 6 K，编译器和和处理器通常会对指令进行指令重排序。
图中的三个重排位置可以调换的，根据系统优化需要进行重排。遵循的原则是单线程重排后的执行结果要与顺序执行结果相同。
(2)l q i | d E : 内存屏障指令：volatile在指令之间插入内存屏障，保证按照特定顺序执行和某些变量的可见性。
volatile就是通过内存屏障通知cpu和编 ! &译器U x f q b J p ;不做指令重排优化来维持有序性。
2. synchronize串行控制
(1) synchronize无禁止指令重排r ? ? L e。
(2) 一个变量在同一时刻只允许一条线程c d r o z对其进行lock操作，获取对象锁，互斥排他性达到两个同步块串行执行。
五. volatile线程安全适用Y Z h ` u k ^范围
由于volatile的非原子性原因，所以它的线程安全是有条件的：
(1) 运算结果不依赖但前置，或者能保证自由一个单一线程修改变量值。
(2) 变量不需要与其他的状态变量共同参与不变的约束。 这两条件描述出自于《深入+ 5 Q T } % e理解java虚拟机》。
六. volatil` W 0 = ] S Ae与synchronize配合使用
1. DCL单例代码
pQ ] d 8ublic class Singleton {
private volatile static SingletoG ? k v g 9 t u zn instance = null;
private Singleton(){
}
publis - K 6 ,c static Singleton getInstance4 ~ $ 4 [ I V k(){
if(instance == null){ // 第①处
syne R H Jchronized: G z 2 (Singleton.class) {
if(instance == null){ // 第②处
in( X - K = a Sstance = new Singl$ r : e } Reton();
}
}
}
return instance;
}
}2.为什么还要使用volatile来修饰
按照上边的写法已经对new Singleton();这个操作进行了synch# e 9 u 3 `ronize操作，已经保证了多线程只能串行执行这个实例化代码。事实上，synchronize保证了线程执行实例化这段代码是串行的，但是Synchronize并不具备禁止指令重排的特性。
而instanc3 1 5 M + S W 9 Ze = new Singleton(); 主要做了3件事情：
(1) java虚拟机为对象分配一块内存x。
(2) 在内存x上为对象进行初始化 。
(3) 将内存x的地址赋值给instance 变量。
如果编译器进行重排为：
(1) java虚拟机为对象分配一块内存x。
(2) 将内存x的地址赋值给instance 变量。
(3) 在内存x上为对象进行初始化 。
第一种情况，g 9 a k 4 g无vola~ L E 9 x f f I ~tile修饰：此时，有两个线程执行getInstance()方法，加入线程A进入代码的注释中的第②处，并执行到了重排指令的（2），与其同时线程B刚好代码注释中的第①处的if[ ? 1 : p M判断。此时，instance有线程A把内存地址x地址赋值给了instance，那么instance已经不为空只是没有初始化完成，线m w 6 ~ _ 8程B就返回了一个没有完成初始化的instance，最终使用时候会出现空指针的错误。
第二种情况，有volatile修饰：instance因为被volatile的禁止指令} n l q p & C重排的特性，那只会安装先初始化对象再赋值给instance这样顺序执行，这样就能保证返回正常的实例化的对象。
七. 小结
1.volatile具有可见性和有序性，不能保证原子性。
2.volat ( 5 ) w n 8 Jtile在特定情况下线$ # 0 O程安全，比如自身不做非原子性运算。
3.sR C k 9 ! 4 mynchronize通过获取对象锁，保证代码块串行执行，无禁止指令重排能力。
4.DCL单例操作需要volatile和synchronize保证线程安全。
点R , t关注，不迷路；持续更新Java相关技术及资讯！！
本文到这里就结束了，喜欢的朋友可以帮忙转发和关注一下，感谢支持！