Java中Volatile關(guān)鍵字能保證原子性嗎

更新時間：2022年08月28日 15:27:03 作者：碼農(nóng)小宋???????

這篇文章主要介紹了Java中Volatile關(guān)鍵字能保證原子性嗎，文章圍繞主題展開詳細(xì)的內(nèi)容介紹，具有一定的參考價值，需要的小伙伴可以參考一下

volatile

volatile 是 Java 中的一個相對來說比較重要的關(guān)鍵字，主要就是用來修飾會被不同線程訪問和修改的變量。

而這個變量只能保證兩個特性，一個是保證有序性，另外一個則是保證可見性。

那么什么是有序性，什么又是可見性呢？

有序性

那么什么是有序性呢？

其實程序執(zhí)行的順序按照代碼的先后順序執(zhí)行，禁止進(jìn)行指令重排序。

看似理所當(dāng)然，其實并不是這樣，指令重排序是JVM為了優(yōu)化指令，提高程序運(yùn)行效率，在不影響單線程程序執(zhí)行結(jié)果的前提下，盡可能地提高并行度。

但是在??多線程??環(huán)境下，有些代碼的順序改變，有可能引發(fā)邏輯上的不正確。

而 volatile 就是因為有這個特性，所以才被大家熟知的。

volatile 又是如何保證有序性的呢？

有很多小伙伴就說，網(wǎng)上說的是 volatile 可以禁止指令指令重排序，這就保證了代碼的程序會嚴(yán)格按照代碼的先后順序執(zhí)行。這就保證了有序性。被 volatile 修飾的變量的操作，會嚴(yán)格按照代碼順序執(zhí)行，就是說當(dāng)代碼執(zhí)行到 volatile 修飾的變量時，其前面的代碼一定執(zhí)行完畢，后面的代碼一定沒有執(zhí)行。

如果這時候，面試官不再繼續(xù)深挖下去的話，那么恭喜你，可能這個問題已經(jīng)回答完了，但是如果面試官繼續(xù)往下深挖，為什么會禁止指令重排，什么又是指令重排呢？

在從源碼到指令的執(zhí)行，一般是分成了三種重排，如圖所示：

我們接下來就得看看 volatile 是如何禁止指令重排的。

我們直接用代碼來進(jì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);
}
}
}

如果有人看到這段代碼，肯定會說，那這段代碼出來的結(jié)果會是什么呢？

有些人說是 2，是的，如果你只是單線程調(diào)用，那結(jié)果就是 2，但是如果是多線程調(diào)用的時候，最后的輸出結(jié)果不一定是我們想象到的 2，這時就要把兩個變量都設(shè)置為 volatile。

如果大家對單例模式了解比較多的話，肯定也是關(guān)注過這個 volatile，為什么呢？

大家看看如下代碼：

class Singleton {
// 不是一個原子性操作
//private static Singleton instance;
//改進(jìn)，Volatile 可以保持可見性，不能保證原子性，由于內(nèi)存屏障，可以保證避免指令重排的現(xiàn)象產(chǎn)生！
private static volatile Singleton instance;

// 構(gòu)造器私有化
private Singleton() {
}

// 提供一個靜態(tài)的公有方法，加入雙重檢查代碼，解決線程安全問題, 同時解決懶加載問題，同時保證了效率, 推薦使用
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

上面的單例模式大家熟悉么？

是的，這就是 **雙重檢查(DCL 懶漢式) **

有人會說，因為有指令重排序的存在，雙端檢索機(jī)制也也不一定是線程安全的呀，對呀，所以用到了 synchronized 關(guān)鍵字，讓他變成了線程安全的了。

可見性

其實可見性就是，在多線程環(huán)境中，對共享變量的修改對于其他線程是否立即可見的問題。

那么他的可見性一般都會表現(xiàn)在什么地方呢？用在什么地方呢？

其實一般用這個變量，很多都是為了保證他的可見性，就比如定義的一個全局變量，在其中有個循環(huán)來判斷這個變量的值，有一個線程修改了這個參數(shù)的時候，這個循環(huán)會停止，跳轉(zhuǎn)到之后去執(zhí)行。

我們來看看沒有使用volatile修飾代碼實現(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)識已經(jīng)變更");
}
}).start();
}
}

結(jié)果大家肯定是可想而知，

運(yùn)行結(jié)果肯定是：

線程A開始執(zhí)行:
線程B開始執(zhí)行
標(biāo)識已經(jīng)變更

確實，就是這樣的。

如果我們用 volatile 呢，那么這個代碼的執(zhí)行結(jié)果就會不一樣呢？

我們來試一下：

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)識已經(jīng)變更");
}
}).start();
}

這樣我們就能看到另外一個執(zhí)行結(jié)果，在循環(huán)當(dāng)中的輸出語句是可以被執(zhí)行的。

也就是說，在線程B 中，我們?nèi)バ薷倪@個被修飾的變量，那么最終，在線程A中，就能順利讀取到我們的數(shù)據(jù)信息了。

是否能夠保證原子性

不能，我們來看一點(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();
}// 后臺默認(rèn)兩個線程：一個是main線程，一個是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，比如：