Volatile關(guān)鍵字能保證原子性么？
說(shuō)到這個(gè) volatile 這個(gè)關(guān)鍵字，阿粉覺(jué)得看過(guò)阿粉文章的，肯定都對(duì)這個(gè)關(guān)鍵字那是非常的熟悉的，因?yàn)樽鯦ava開發(fā)的，在面試的時(shí)候，如果涉及到多線程，那么面試官有不少人會(huì)詢問(wèn)關(guān)于 volatile 這個(gè)關(guān)鍵字的使用，以及他的作用，今天阿粉就來(lái)說(shuō)說(shuō)這個(gè) volatile 關(guān)鍵的的作用，以及他的一些特性。
volatile
volatile 是 Java 中的一個(gè)相對(duì)來(lái)說(shuō)比較重要的關(guān)鍵字，主要就是用來(lái)修飾會(huì)被不同線程訪問(wèn)和修改的變量。
而這個(gè)變量只能保證兩個(gè)特性，一個(gè)是保證有序性，另外一個(gè)則是保證可見(jiàn)性。
那么什么是有序性，什么又是可見(jiàn)性呢？
有序性
那么什么是有序性呢？
其實(shí)程序執(zhí)行的順序按照代碼的先后順序執(zhí)行，禁止進(jìn)行指令重排序。
看似理所當(dāng)然，其實(shí)并不是這樣，指令重排序是JVM為了優(yōu)化指令，提高程序運(yùn)行效率，在不影響單線程程序執(zhí)行結(jié)果的前提下，盡可能地提高并行度。
但是在多線程環(huán)境下，有些代碼的順序改變，有可能引發(fā)邏輯上的不正確。
而 volatile 就是因?yàn)橛羞@個(gè)特性，所以才被大家熟知的。
volatile 又是如何保證有序性的呢？
有很多小伙伴就說(shuō)，網(wǎng)上說(shuō)的是 volatile 可以禁止指令指令重排序，這就保證了代碼的程序會(huì)嚴(yán)格按照代碼的先后順序執(zhí)行。這就保證了有序性。被 volatile 修飾的變量的操作，會(huì)嚴(yán)格按照代碼順序執(zhí)行，就是說(shuō)當(dāng)代碼執(zhí)行到 volatile 修飾的變量時(shí)，其前面的代碼一定執(zhí)行完畢，后面的代碼一定沒(méi)有執(zhí)行。
如果這時(shí)候，面試官不再繼續(xù)深挖下去的話，那么恭喜你，可能這個(gè)問(wèn)題已經(jīng)回答完了，但是如果面試官繼續(xù)往下深挖，為什么會(huì)禁止指令重排，什么又是指令重排呢？
在從源碼到指令的執(zhí)行，一般是分成了三種重排，如圖所示：
我們接下來(lái)就得看看 volatile 是如何禁止指令重排的。
我們直接用代碼來(lái)進(jìn)行驗(yàn)證。
public class ReSortDemo {
int a = 0;
boolean flag = false;
public void mehtod1(){
a = 1;
flag = true;
}
public void method2(){
if(flag){
a = a +1;
System.out.println("最后的值: "+a);
}
}
}
如果有人看到這段代碼，肯定會(huì)說(shuō)，那這段代碼出來(lái)的結(jié)果會(huì)是什么呢？
有些人說(shuō)是 2，是的， 如果你只是單線程調(diào)用，那結(jié)果就是 2，但是如果是多線程調(diào)用的時(shí)候，最后的輸出結(jié)果不一定是我們想象到的 2，這時(shí)就要把兩個(gè)變量都設(shè)置為 volatile。
如果大家對(duì)單例模式了解比較多的話，肯定也是關(guān)注過(guò)這個(gè) volatile，為什么呢？
大家看看如下代碼：
class Singleton {
// 不是一個(gè)原子性操作
//private static Singleton instance;
//改進(jìn)，Volatile 可以保持可見(jiàn)性，不能保證原子性，由于內(nèi)存屏障，可以保證避免指令重排的現(xiàn)象產(chǎn)生！
private static volatile Singleton instance;
// 構(gòu)造器私有化
private Singleton() {
}
// 提供一個(gè)靜態(tài)的公有方法，加入雙重檢查代碼，解決線程安全問(wèn)題, 同時(shí)解決懶加載問(wèn)題，同時(shí)保證了效率, 推薦使用
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
上面的單例模式大家熟悉么？
是的，這就是 **雙重檢查(DCL 懶漢式) **
有人會(huì)說(shuō)，因?yàn)橛兄噶钪嘏判虻拇嬖?，雙端檢索機(jī)制也也不一定是線程安全的呀，對(duì)呀，所以阿粉用到了 synchronized 關(guān)鍵字，讓他變成了線程安全的了。
可見(jiàn)性
其實(shí)可見(jiàn)性就是，在多線程環(huán)境中，對(duì)共享變量的修改對(duì)于其他線程是否立即可見(jiàn)的問(wèn)題。
那么他的可見(jiàn)性一般都會(huì)表現(xiàn)在什么地方呢？用在什么地方呢？
其實(shí)在阿粉的感知中，一般用這個(gè)變量，很多都是為了保證他的可見(jiàn)性，就比如定義的一個(gè)全局變量，在其中有個(gè)循環(huán)來(lái)判斷這個(gè)變量的值，有一個(gè)線程修改了這個(gè)參數(shù)的時(shí)候，這個(gè)循環(huán)會(huì)停止，跳轉(zhuǎn)到之后去執(zhí)行。
我們來(lái)看看沒(méi)有使用volatile修飾代碼實(shí)現(xiàn)：
public class Test {
private static boolean flag = false;
public static void main(String[] args) throws Exception{
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("線程A開始執(zhí)行:");
for (;;){
if (flag){
System.out.println("跳出循環(huán)");
break;
}
}
}
}).start();
Thread.sleep(100);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("線程B開始執(zhí)行");
flag = true;
System.out.println("標(biāo)識(shí)已經(jīng)變更");
}
}).start();
}
}
結(jié)果大家肯定是可想而知。
運(yùn)行結(jié)果肯定是：
線程A開始執(zhí)行:
線程B開始執(zhí)行
標(biāo)識(shí)已經(jīng)變更
確實(shí)，就是這樣的。
如果我們用 volatile 呢，那么這個(gè)代碼的執(zhí)行結(jié)果就會(huì)不一樣呢？
我們來(lái)試一下：
public class Test {
private static volatile boolean flag = false;
public static void main(String[] args) throws Exception{
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("線程A開始執(zhí)行:");
for (;;){
if (flag){
System.out.println("跳出循環(huán)");
break;
}
}
}
}).start();
Thread.sleep(100);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("線程B開始執(zhí)行");
flag = true;
System.out.println("標(biāo)識(shí)已經(jīng)變更");
}
}).start();
}
這樣我們就能看到另外一個(gè)執(zhí)行結(jié)果，在循環(huán)當(dāng)中的輸出語(yǔ)句是可以被執(zhí)行的。
也就是說(shuō)，在線程B 中，我們?nèi)バ薷倪@個(gè)被修飾的變量，那么最終，在線程A中，就能順利讀取到我們的數(shù)據(jù)信息了。
是否能夠保證原子性
不能，我們來(lái)看一點(diǎn)代碼，被volatile修飾的變量；
public class Test {
// volatile不保證原子性
// 原子性：保證數(shù)據(jù)一致性、完整性
volatile int number = 0;
public void addPlusPlus() {
number++;
}
public static void main(String[] args) {
Test volatileAtomDemo = new Test();
for (int j = 0; j < 20; j++) {
new Thread(() -> {
for (int i = 0; i < 1000; i++) {
volatileAtomDemo.addPlusPlus();
}
}, String.valueOf(j)).start();
}// 后臺(tái)默認(rèn)兩個(gè)線程：一個(gè)是main線程，一個(gè)是gc線程
while (Thread.activeCount() > 2) {
Thread.yield();
}
// 如果volatile保證原子性的話，最終的結(jié)果應(yīng)該是20000 // 但是每次程序執(zhí)行結(jié)果都不等于20000
System.out.println(Thread.currentThread().getName() +
" final number result = " + volatileAtomDemo.number);
}
}
如果能夠保原子性，那么最終的結(jié)果應(yīng)該是20000，但是每次的最終結(jié)果并不能保證就是20000，比如：
main final number result = 17114
main final number result = 20000
main final number result = 19317
三次執(zhí)行，都是不同的結(jié)果。
為什么會(huì)出現(xiàn)這種呢？這就和number++有關(guān)系了。
number++被拆分成3個(gè)指令：
- 執(zhí)行GETFIELD拿到主內(nèi)存中的原始值number。
- 執(zhí)行IADD進(jìn)行加1操作。
- 執(zhí)行PUTFIELD把工作內(nèi)存中的值寫回主內(nèi)存中。
當(dāng)多個(gè)線程并發(fā)執(zhí)行PUTFIELD指令的時(shí)候，會(huì)出現(xiàn)寫回主內(nèi)存覆蓋問(wèn)題，所以才會(huì)導(dǎo)致最終結(jié)果不為 20000，所以 volatile 不能保證原子性。
所以，你知道怎么回答了么？
