共计 3184 个字符，预计需要花费 8 分钟才能阅读完成。
1.Volatile 关键字是什么?
2.Volatile 关键字的作用
2.1 JMM（JAVA 内存模型）的了解
2.2 Volatile 的保障可见性
2.3 Volatile 禁止指令重排序
3. 用 volitile 改写单例模式
1.Volatile 关键字是什么?
咱们都晓得 synchronize 关键字，是哟中分量型的同步机制，相对而言，volitile 是一种轻量级的同步机制，volatile 字面有“易挥发”的意思，Volatile 关键字用于润饰共享可变变量，因为被润饰的值容易变动（容易被其它线程更改），因为不确定。volatile 它有与锁雷同的作用：保障可见性和有序性，所不同的是，在原子性方面只保障写变量操作的原子性，单没有锁排他性。
2.Volatile 关键字的作用
1. 保障可见性
2. 不保障原子性
3. 禁止指令重排
咱们先解释第一点，保障可见性，可见性咱们要从 JMM（JAVA 内存模型）开始讲起
2.1 JMM（JAVA 内存模型）的了解
JMM 并不实在存在，它形容的是一组标准
JVM 工作线程工作的时候，是有本人的工作内存的，工作内存是每个线程的公有区域，而 java 所有变量都保留在主存，主存是共享区域。线程在运行的时候，会先把变量拷贝一份到本人的工作内存，而后对变量进行赋值操作，操作实现后再将变量写会主存。并不能间接操作主内存变量，各个线程的工作内存中存储着主存的变量正本拷贝，因而不同的线程无法访问对方的工作主存，线程的通信必须通过内存来实现，这就是 JMM。
2.2 Volatile 的保障可见性
晓得了 JMM 线程模型之后，咱们就能够晓得，主内存的变量，都是要被拷贝到工作线程的工作空间后，再进行操作。如果此时主内存理得变量发生变化，工作线程是感知不到的，咱们能够用代码来进行示范：
public class MyData {
int number = 0;
public void addTo60(){this.number = 60;}
public void add(){this.number++;}
咱们先定义一个类，MyData，只有一个一般 int 变量。
再定义一个测试类：
public class VisibleTest {public static void main(String[] args) {MyData myData = new MyData();
new Thread(() -> {System.out.println(Thread.currentThread().getName() + "comm in");
myData.number = myData.number ++;
System.out.println("myData"+myData.number);
}).start();
while(myData.number==0){System.out.println(myData.number);
}
System.out.println(Thread.currentThread().getName()+"over");
}
}此时咱们通常会认为，number 随着变量值的批改，会进行 while 循环的操作，然而后果并不会。
这是因为变量在拷贝回线程，批改值后并没有返回主存，导致另外一个线程感知不到，当初咱们加上 Volatile 关键字：
volatile int number = 0;
线程顺利完结了！
这是因为加上 volatile 后，每次线程都要去主存来读取值，每次写完值后都要放回主存！
咱们查看字节码文件：
其中 getfield 和 putfield 都是从主存中获取和批改值。
然而 volatile 只保障读和写的和见性，并没有保障写的排他性，所以也就没有保障原子性。
2.2.1 内存屏障指令
volatile 之所以能保障可见性和避免重排序，是因为他的底层是内存屏障指令：
内存屏障，是一个 cpu 指令，作用有两个：
一是保障特定操作的执行程序
二是保障某些变量的内存可见性
因为编译器和处理器都能执行指令重排优化，如果在指令间插入一条 memory barrier 则会通知编译器和 cpu
，不论什么指令都不能和这条指令重排序，也就是说，通过内存屏障指令禁止在内存屏障前后的指令执行从新排序优化
内存屏障指令另一个作用是强制刷出各种 cpu 的缓存数据，因而任何 cpu 上的线程都能读取到这些数据的最新版本
2.3 Volatile 禁止指令重排序
对于指令重排，咱们先来举一个例子：
int x = 11; //1
int y = 15; //2
x = x + 5; //3
y = x * x; //4这是四条简略的代码，咱们都晓得最初 x = 16,y = 16 * 16
如果咱们不晓得指令重排序的话，可能只是简略地认为，语句的执行程序为 1234 而已。
其实，计算机在执行程序的时候，为了进步性能，编译器和处理器经常会对指令进行重排，个别有以下三种：
源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存零碎的重排 -> 最终执行的指令
单线程环境里确保程序最终执行后果和代码执行的后果统一：也就是说，单线程环境无论如何重排指令，最终的后果都是统一的。
处理器在进行重排序时必须思考指令之间的数据依赖性：也就是说，上述命令，4 肯定在 3 前面，1 肯定在 3 后面，不然就无奈保障最终一致性了。
好的，单线程环境下没什么问题，接下来咱们看多线程环境下：
两个线程同时运行时吗，就会呈现这种后果，也可能会呈现上面这种后果：
这样最终的后果就会不确定了，而 volatile 关键字就防止了指令重排序，依照编码的程序来进行编译执行！
3. 用 volitile 改写单例模式
通常咱们认为的单例模式，在单线程下，都是这么写的
public class SingletomDeomo {
private static volatile SingletomDeomo instance = null;
private SingletomDeomo() {System.out.println(Thread.currentThread().getName() + "\t 构造方法 singletom");
}
public static SingletomDeomo getInstance(){if(instance ==null){instance = new SingletomDeomo();
}
return instance;
}
}
然而在多线程环境下，运行起来就会产生多个实例，那是因为因为上下文的切换，很多线程在判断完 if 为空后，工夫片被别的线程夺去，而后别的线程又 new 了 instance，导致当初的线程夺回工夫片后，又会持续 new 一个对象。
public static void main(String[] args) {for (int i = 0; i < 100; i++) {new Thread(() -> {SingletomDeomo.getInstance();
}).start();}
}为了解决这个问题，咱们能够在这个办法上加上 synchronize 关键字，然而这样运行起来太重，咱们能够应用 dcl（double check lock）双重校验锁来解决。
if (instance == null) {synchronized (SingletomDeomo.class) {if (instance == null) {instance = new SingletomDeomo();
}
}
}此时，如果 instance 不加 volatile 关键字，还是会有问题。
咱们要仔细分析一下 instance = new SingletomDemo(); 里的步骤：
- 1.memory = allocate();
- 2.instance(memory);
- 3.instance = memory;
大略就是这么三步：
1. 调配一块内存区域
2. 将这块内存区域初始化
3. 将这块内存区域调配给 instance
留神：此时，这三步也是能够被重排序的！
所以，在 instance 上加上 volatile 就没事了！
以上便是对 volatile 的学习笔记。