image.png

簡介
volatile是Java提供的一種輕量級的同步機(jī)制。Java 語言包含兩種內(nèi)在的同步機(jī)制：同步塊（或方法）和 volatile 變量，相比于synchronized（synchronized通常稱為重量級鎖）啃憎，volatile更輕量級偷溺，因為它不會引起線程上下文的切換和調(diào)度划煮。但是volatile 變量的同步性較差（有時它更簡單并且開銷更低）裆操，而且其使用也更容易出錯官地。

Java volatile關(guān)鍵字用于將Java變量標(biāo)記為“存儲在主存儲器中”酿傍。更確切地說，這意味著驱入，每次讀取一個volatile變量都將從計算機(jī)的主內(nèi)存中讀取赤炒，而不是從CPU緩存中讀取，并且每次寫入volatile變量都將寫入主內(nèi)存亏较，而不僅僅是CPU緩存莺褒。

實際上，自Java 5以來雪情，volatile關(guān)鍵字保證的不僅僅是向主存儲器寫入和讀取volatile變量遵岩。

原子性

即一個操作或者多個操作 要么全部執(zhí)行并且執(zhí)行的過程不會被任何因素打斷，要么就都不執(zhí)行巡通。

原子性是拒絕多線程操作的尘执，不論是多核還是單核，具有原子性的量宴凉，同一時刻只能有一個線程來對它進(jìn)行操作誊锭。簡而言之，在整個操作過程中不會被線程調(diào)度器中斷的操作弥锄，都可認(rèn)為是原子性丧靡。例如 a=1是原子性操作，但是a++和a +=1就不是原子性操作籽暇。Java中的原子性操作包括：

• 基本類型的讀取和賦值操作温治，且賦值必須是數(shù)字賦值給變量，變量之間的相互賦值不是原子性操作戒悠。
• 所有引用reference的賦值操作
• java.concurrent.Atomic.* 包中所有類的一切操作

可見性

指當(dāng)多個線程訪問同一個變量時熬荆，一個線程修改了這個變量的值，其他線程能夠立即看得到修改的值救崔。

在多線程環(huán)境下惶看，一個線程對共享變量的操作對其他線程是不可見的。Java提供了volatile來保證可見性六孵，當(dāng)一個變量被volatile修飾后纬黎，表示著線程本地內(nèi)存無效，當(dāng)一個線程修改共享變量后他會立即被更新到主內(nèi)存中劫窒，其他線程讀取共享變量時本今，會直接從主內(nèi)存中讀取。當(dāng)然，synchronize和Lock都可以保證可見性冠息。synchronized和Lock能保證同一時刻只有一個線程獲取鎖然后執(zhí)行同步代碼挪凑，并且在釋放鎖之前會將對變量的修改刷新到主存當(dāng)中。因此可以保證可見性逛艰。

在線程使用非volatile變量的多線程應(yīng)用程序中躏碳，出于性能原因，每個線程可以在處理它們時將變量從主存儲器拷貝到CPU高速緩存中散怖。如果您的計算機(jī)包含多個CPU菇绵，則每個線程可以在不同的CPU上運行。這意味著镇眷，每個線程都可以將變量復(fù)制到不同CPU的CPU緩存中咬最。這在這里說明：

image.png

對于volatile變量，無法保證Java虛擬機(jī)（JVM）何時將數(shù)據(jù)從主內(nèi)存讀取到CPU緩存中欠动，或?qū)?shù)據(jù)從CPU緩存寫入主內(nèi)存永乌。這可能會導(dǎo)致一些問題，我將在以下部分中解釋具伍。

想象一下兩個或多個線程可以訪問共享對象的情況翅雏，該共享對象包含一個聲明如下的計數(shù)器變量：

public class SharedObject {
    public int counter = 0;
}

再想象一下，只有線程1對counter變量進(jìn)行增加操作沿猜，但線程1和線程2都可能讀取變量counter枚荣。
如果counter變量未聲明volatile，則無法保證何時將counter變量的值從CPU緩存寫回主存儲器啼肩。這意味著，CPU高速緩存中的counter變量值可能與主存儲器中的變量值不同衙伶。這種情況如下所示：

image.png

線程沒有看到變量的最新值的問題祈坠，是因為它還沒有被另一個線程寫回主內(nèi)存，這被稱為“可見性”問題矢劲，其他線程看不到一個線程的某些更新赦拘。

volatile可見性保證
Java volatile關(guān)鍵字旨在解決變量可見性問題。通過使用volatile聲明counter變量芬沉，對變量counter的所有寫操作都將立即寫回主存儲器躺同。此外，counter變量的所有讀取都將直接從主存儲器中讀取丸逸。

下面是counter變量聲明為volatile的樣子：

public class SharedObject {
    public volatile int counter = 0;
}

聲明變量為volatile蹋艺，對其他線程寫入該變量 保證了可見性

在上面給出的場景中，一個線程（T1）修改計數(shù)器黄刚，另一個線程（T2）讀取計數(shù)器（但從不修改它）捎谨，聲明該counter變量為volatile足以保證寫入counter變量對T2的可見性。

但是，如果T1和T2都在增加counter變量涛救，那么聲明counter變量為volatile就不夠了畏邢。稍后會詳細(xì)介紹。

完全volatile可見性保證

• 如果線程A寫入volatile變量并且線程B隨后讀取這個volatile變量检吆，則在寫入volatile變量之前對線程A可見的所有變量在線程B讀取volatile變量后也將對線程B可見舒萎。

• 如果線程A讀取volatile變量，則讀取volatile變量時對線程A可見的所有變量也將從主存儲器重新讀取蹭沛。

代碼示例

public class MyClass {
    private int years;
    private int months
    private volatile int days;

    public void update(int years, int months, int days){
        this.years  = years;
        this.months = months;
        this.days   = days;
    }
}

udpate()方法寫入三個變量臂寝，其中只有days是volatile變量。

完全volatile可見性保證意味著致板，當(dāng)將一個值寫入days時交煞，對線程可見的其他所有變量也會寫入主存儲器。這意味著斟或，當(dāng)一個值被寫入days素征，years和months的值也被寫入主存儲器(注意days的寫入在最后)。

當(dāng)讀取years萝挤，months和days的值你可以這樣做：

public class MyClass {
    private int years;
    private int months
    private volatile int days;

    public int totalDays() {
        int total = this.days;
        total += months * 30;
        total += years * 365;
        return total;
    }

    public void update(int years, int months, int days){
        this.years  = years;
        this.months = months;
        this.days   = days;
    }
}

注意totalDays()方法通過讀取days的值到total變量中開始御毅。當(dāng)讀取days的值時，后續(xù)months 和years值的讀取也會從主存儲器中讀取怜珍。因此使用上述讀取序列可以保證看到最新的days端蛆，months和years值。

有序性

即程序執(zhí)行的順序按照代碼的先后順序執(zhí)行酥泛。

java內(nèi)存模型中的有序性可以總結(jié)為：如果在本線程內(nèi)觀察今豆，所有操作都是有序的；如果在一個線程中觀察另一個線程柔袁，所有操作都是無序的呆躲。前半句是指“線程內(nèi)表現(xiàn)為串行語義”，后半句是指“指令重排序”現(xiàn)象和“工作內(nèi)存主主內(nèi)存同步延遲”現(xiàn)象捶索。
在Java內(nèi)存模型中插掂，為了效率是允許編譯器和處理器對指令進(jìn)行重排序，當(dāng)然重排序不會影響單線程的運行結(jié)果腥例，但是對多線程會有影響辅甥。Java提供volatile來保證一定的有序性。最著名的例子就是單例模式里面的DCL（雙重檢查鎖）燎竖。另外璃弄，可以通過synchronized和Lock來保證有序性，synchronized和Lock保證每個時刻是有一個線程執(zhí)行同步代碼底瓣，相當(dāng)于是讓線程順序執(zhí)行同步代碼谢揪，自然就保證了有序性蕉陋。

volatile變量的特性

保證可見性，不保證原子性

image.png

• 當(dāng)寫一個volatile變量時拨扶，JMM會把該線程本地內(nèi)存中的變量強(qiáng)制刷新到主內(nèi)存中去凳鬓；

• 這個寫會操作會導(dǎo)致其他線程中的緩存無效。

禁止指令重排

重排序是指編譯器和處理器為了優(yōu)化程序性能而對指令序列進(jìn)行排序的一種手段患民。重排序需要遵守一定規(guī)則：

• 重排序操作不會對存在數(shù)據(jù)依賴關(guān)系的操作進(jìn)行重排序缩举。

比如：a=1;b=a; 這個指令序列，由于第二個操作依賴于第一個操作匹颤，所以在編譯時和處理器運
行時這兩個操作不會被重排序仅孩。

• 重排序是為了優(yōu)化性能，但是不管怎么重排序印蓖，單線程下程序的執(zhí)行結(jié)果不能被改變

比如：a=1;b=2;c=a+b這三個操作辽慕，第一步（a=1)和第二步(b=2)由于不存在數(shù)據(jù)依賴關(guān)系， 所以可能會發(fā)
生重排序赦肃，但是c=a+b這個操作是不會被重排序的溅蛉，因為需要保證最終的結(jié)果一定是c=a+b=3。
重排序在單線程下一定能保證結(jié)果的正確性他宛，但是在多線程環(huán)境下船侧，可能發(fā)生重排序，影響結(jié)果厅各，下例中的1和2由于不存在數(shù)據(jù)依賴關(guān)系镜撩，則有可能會被重排序，先執(zhí)行status=true再執(zhí)行a=2队塘。而此時線程B會順利到達(dá)4處袁梗，而線程A中a=2這個操作還未被執(zhí)行，所以b=a+1的結(jié)果也有可能依然等于2憔古。

hapens-before原則

為了解決指令重排序挑戰(zhàn)围段，除了可見性保證之外，Java volatile關(guān)鍵字還提供“happens-before”保證投放。

1.代碼執(zhí)行順序原則,代碼的執(zhí)行順序,編寫在前面的發(fā)生在編寫在后面的之前
2.鎖原則,unlock后于lock
3.線程啟動原則,start方法優(yōu)先于run方法
4.對象銷毀原則,初始化必須發(fā)生在finalize之前
5.線程終結(jié)原則,所有操作發(fā)生在線程死亡之前
6.volatile修飾的變量,寫操作優(yōu)先于讀操作
7.傳遞性原則,操作A先于B，B先于C适贸，那么A肯定先于C
8.線程中斷原則,interrupt這個動作,必須發(fā)生在捕獲該動作之前

八大原則
代碼執(zhí)行順序,鎖原則,線程原則(3個灸芳，start優(yōu)先于run,interrupt優(yōu)先于捕獲,線程終結(jié)在最后),對象的生命周期(初始化優(yōu)先于finnalize),傳遞性原則,volatile

volatile 之前讀寫

如果讀取/寫入最初發(fā)生在寫入volatile變量之前，讀取/寫入其他變量不能重新排序在寫入volatile變量之后拜姿。
寫入volatile變量之前的讀/寫操作被保證 “happen before” 寫入volatile變量烙样。請注意，發(fā)生在寫入volatile變量之后的讀/寫操作依然可以重排序到寫入volatile變量前键袱，只是不能相反语稠。允許從后到前，但不允許從前到后瘤礁。

volatile 之后讀寫

如果讀/寫操作最初發(fā)生在讀取volatile變量之后批狱，則讀取/寫入其他變量不能重排序到發(fā)生在讀取volatile變量之前裸准。請注意，發(fā)生在讀取volatile變量之前的讀/寫操作依然可以重排序到讀取volatile變量后赔硫，只是不能相反炒俱。允許從前到后，但不允許從后到前爪膊。

上述 “happens-before”規(guī)則保證確保volatile關(guān)鍵字的可見性保證在強(qiáng)制執(zhí)行权悟。

public class VolatileTest {
    private volatile int vi = 1;
    private int i = 2;
    private int i2 = 3;

    @Test
    public void test() {
        System.out.println(i);      //1  讀取普通變量
        i=3;                        //2  寫入普通變量

        //1 2 不能重排序到3之后，操作4可以重排序到3前面
        vi = 2;                     //3  寫入volatile變量
        i2 = 5;                     //4  寫入普通變量
    }

    @Test
    public void test2() {
        System.out.println(i);      //1  讀取普通變量

        //3不能重排序到在2前推盛，但1可以重排序到2后
        System.out.println(vi);     //2  讀取volatile變量
        System.out.println(i2);     //3  讀取普通變量
    }
}

volatile注意事項

volatile 線程不安全

即使volatile關(guān)鍵字保證volatile變量的所有讀取直接從主存儲器讀取峦阁，并且所有對volatile變量的寫入都直接寫入主存儲器，仍然存在聲明volatile變量線程不安全耘成。

在前面解釋的情況中榔昔，只有線程1寫入共享counter變量，聲明counter變量為volatile足以確保線程2始終看到最新的寫入值凿跳。

實際上件豌，如果寫入volatile變量的新值不依賴于其先前的值，則甚至可以多個線程寫入共享變量控嗜，并且仍然可以在主存儲器中存儲正確的值茧彤。換句話說，就是將值寫入共享volatile變量的線程開始并不需要讀取其舊值來計算其下一個值疆栏。

一旦線程需要首先讀取volatile變量的舊值曾掂，并且基于該值為共享volatile變量生成新值，volatile變量就不再足以保證正確的可見性壁顶。讀取volatile 變量和寫入新值之間的短時間間隔會產(chǎn)生競爭條件 珠洗，其中多個線程可能讀取volatile變量的同一個舊值，然后為其生成新值若专，并將該值寫回主內(nèi)存 - 覆蓋彼此的值许蓖。

多個線程遞增同一個計數(shù)器的情況正是 volatile變量并不安全的情況。以下部分更詳細(xì)地解釋了這種情況调衰。

想象一下膊爪，如果線程1將值為0的共享變量counter讀入其CPU高速緩存，將其增加到1并且不將更改的值寫回主存儲器嚎莉。然后米酬，線程2也從主存儲器讀取相同的counter變量進(jìn)入自己的CPU高速緩存，其中變量的值仍為0趋箩。然后赃额，線程2也將計數(shù)器遞增到1加派，也不將其寫回主存儲器。這種情況如下圖所示：

image.png

線程1和線程2現(xiàn)在失去了同步跳芳。共享變量counter的實際值應(yīng)為2芍锦，但每個線程的CPU緩存中的變量值為1，而在主內(nèi)存中筛严，該值仍為0醉旦。這是一個混亂！即使線程最終將共享變量counter的值寫回主存儲器桨啃，該值也將是錯誤的车胡。

保證線程安全

正如我前面提到的，如果兩個線程都在讀取和寫入共享變量照瘾，那么使用 volatile關(guān)鍵字是不安全的匈棘。 在這種情況下，您需要使用synchronized來保證變量的讀取和寫入是原子性的析命。讀取或?qū)懭胍粋€volatile變量不會阻塞其他線程讀取或?qū)懭脒@個變量主卫。為此，您必須在臨界區(qū)周圍使用synchronized關(guān)鍵字鹃愤。

作為synchronized塊的替代方法簇搅，您還可以使用java.util.concurrent包中眾多的原子數(shù)據(jù)類型。例如软吐，AtomicLong或者 AtomicReference或其他的瘩将。

如果只有一個線程讀取和寫入volatile變量的值，而其他線程只讀取這個變量凹耙，那么此線程將保證其他線程能看到volatile變量的最新值姿现。如果不將變量聲明為volatile，則無法保證肖抱。

volatile關(guān)鍵字也可以保證在64位變量上正常使用备典。

volatile的性能考慮

讀取和寫入volatile變量會導(dǎo)致變量從主存中讀取或?qū)懭胫鞔妫x取和寫入主內(nèi)存比訪問CPU緩存開銷更大意述。訪問volatile變量也會阻止指令重排序提佣，這是一種正常的性能提升技術(shù)。因此荤崇，當(dāng)您確實需要強(qiáng)制實施變量可見性時镐依，才使用volatile變量。

原理

volatile可以保證線程可見性且提供了一定的有序性天试，但是無法保證原子性。在JVM底層volatile是采用“內(nèi)存屏障”來實現(xiàn)的然低。觀察加入volatile關(guān)鍵字和沒有加入volatile關(guān)鍵字時所生成的匯編代碼發(fā)現(xiàn)喜每，加入volatile關(guān)鍵字時务唐，會多出一個lock前綴指令，lock前綴指令實際上相當(dāng)于一個內(nèi)存屏障（也成內(nèi)存柵欄）带兜，內(nèi)存屏障會提供3個功能：

• 它確保指令重排序時不會把其后面的指令排到內(nèi)存屏障之前的位置枫笛，也不會把前面的指令排到內(nèi)存屏障的后面；即在執(zhí)行到內(nèi)存屏障這句指令時刚照，在它前面的操作已經(jīng)全部完成刑巧；
• 它會強(qiáng)制將對緩存的修改操作立即寫入主存；
• 如果是寫操作无畔，它會導(dǎo)致其他CPU中對應(yīng)的緩存行無效啊楚。

內(nèi)存語義

volatile寫的內(nèi)存語義
當(dāng)寫一個 volatile 變量時，JMM 會把該線程對應(yīng)的本地內(nèi)存中的共享變量值刷新到主內(nèi)存浑彰。

以上面示例程序VolatileExample為例恭理，假設(shè)線程A首先執(zhí)行writer()方法，隨后線程B執(zhí)行reader()方法郭变，初始時兩個線程的本地內(nèi)存中的flag和a都是初始狀態(tài)颜价。下圖是線程A執(zhí)行volatile寫后，共享變量的狀態(tài)示意圖：

image.png

如上圖所示诉濒，線程A在寫flag變量后周伦，本地內(nèi)存A中被線程A更新過的兩個共享變量的值被刷新到主內(nèi)存中。此時未荒，本地內(nèi)存A和主內(nèi)存中的共享變量的值是一致的专挪。

volatile讀的內(nèi)存語義
當(dāng)讀一個 volatile 變量時，JMM 會把該線程對應(yīng)的本地內(nèi)存置為無效茄猫。線程接下來將從主內(nèi)存中讀取共享變量狈蚤。

下面是線程 B 讀同一個 volatile 變量后，共享變量的狀態(tài)示意圖：

image.png

如上圖所示划纽，在讀flag變量后脆侮，本地內(nèi)存B已經(jīng)被置為無效。此時勇劣，線程B必須從主內(nèi)存中讀取共享變量靖避。線程B的讀取操作將導(dǎo)致本地內(nèi)存B與主內(nèi)存中的共享變量的值也變成一致的了。

如果我們把volatile寫和volatile讀這兩個步驟綜合起來看的話比默，在讀線程B讀一個volatile變量后幻捏，寫線程A在寫這個volatile變量之前所有可見的共享變量的值都將立即變得對讀線程B可見。

小結(jié)
下面對volatile寫和volatile讀的內(nèi)存語義做個總結(jié)

• 線程A寫一個volatile變量命咐，實質(zhì)上是線程A向接下來將要讀這個volatile變量的某個線程發(fā)出了（其對共享變量所在修改的）消息篡九。

• 線程B讀一個volatile變量，實質(zhì)上是線程B接收了之前某個線程發(fā)出的（在寫這個volatile變量之前對共享變量所做修改的）消息醋奠。

• 線程A寫一個volatile變量榛臼，隨后線程B讀這個volatile變量伊佃，這個過程實質(zhì)上是線程A通過主內(nèi)存向線程B發(fā)送消息。

volatile內(nèi)存語義的實現(xiàn)

前文我們提到過重排序分為編譯器重排序和處理器重排序沛善。為了實現(xiàn)volatile內(nèi)存語義航揉，JMM會分別限制這兩種類型的重排序類型。下面是JMM針對編譯器制定的volatile重排序規(guī)則表：

舉例來說金刁，第三行最后一個單元格的意思是：在程序順序中帅涂，當(dāng)?shù)谝粋€操作為普通變量的讀或?qū)憰r，如果第二個操作為volatile寫尤蛮，則編譯器不能重排序這兩個操作媳友。

從上表我們可以看出

• 當(dāng)?shù)诙€操作為volatile寫操作時,不管第一個操作是什么(普通讀寫或者volatile讀寫),都不能進(jìn)行重排序。這個規(guī)則確保volatile寫之前的所有操作都不會被重排序到volatile寫之后;
• 當(dāng)?shù)谝粋€操作為volatile讀操作時,不管第二個操作是什么,都不能進(jìn)行重排序抵屿。這個規(guī)則確保volatile讀之后的所有操作都不會被重排序到volatile讀之前;
• 當(dāng)?shù)谝粋€操作是volatile寫操作時,第二個操作是volatile讀操作,不能進(jìn)行重排序庆锦。

為了實現(xiàn) volatile 的內(nèi)存語義，編譯器在生成字節(jié)碼時轧葛，會在指令序列中插入內(nèi)存屏障來禁止特定類型的處理器重排序搂抒。下面是基于保守策略的 JMM 內(nèi)存屏障插入策略：

• 在每個 volatile 寫操作的前面插入一個 StoreStore 屏障（禁止前面的寫與volatile寫重排序）。

• 在每個 volatile 寫操作的后面插入一個 StoreLoad 屏障（禁止volatile寫與后面可能有的讀和寫重排序）尿扯。

• 在每個 volatile 讀操作的后面插入一個 LoadLoad 屏障（禁止volatile讀與后面的讀操作重排序）求晶。

• 在每個 volatile 讀操作的后面插入一個 LoadStore 屏障（禁止volatile讀與后面的寫操作重排序）。

  其中重點說下StoreLaod屏障衷笋，它是確狈夹樱可見性的關(guān)鍵，因為它會將屏障之前的寫緩沖區(qū)中的數(shù)據(jù)全部刷新到主內(nèi)存中辟宗。上述內(nèi)存屏障插入策略非常保守爵赵，但它可以保證在任意處理平臺，任意的程序中都能得到正確的volatile語義泊脐。下面是保守策略（為什么說保守呢空幻，因為有些在實際的場景是可省略的）下，volatile 寫操作 插入內(nèi)存屏障后生成的指令序列示意圖：

image

其中StoreStore屏障可以保證在volatile寫之前容客，其前面的所有普通寫操作對任意處理器可見（把它刷新到主內(nèi)存）秕铛。

另外volatile寫后面有StoreLoad屏障，此屏障的作用是避免volatile寫與后面可能有的讀或?qū)懖僮鬟M(jìn)行重排序缩挑。因為編譯器常常無法準(zhǔn)確判斷在一個volatile寫的后面是否需要插入一個StoreLoad屏障（比如但两，一個volatile寫之后方法立即return）為了保證能正確實現(xiàn)volatile的內(nèi)存語義，JMM采取了保守策略：在每個volatile寫的后面插入一個StoreLoad屏障供置。因為volatile寫-讀內(nèi)存語義的常見模式是：一個寫線程寫volatile變量谨湘，多個度線程讀同一個volatile變量。當(dāng)讀線程的數(shù)量大大超過寫線程時，選擇在volatile寫之后插入StoreLoad屏障將帶來可觀的執(zhí)行效率的提升悲关。從這里也可看出JMM在實現(xiàn)上的一個特點：首先確保正確性谎僻，然后再去追求效率（其實我們工作中編碼也是一樣）。

下面是在保守策略下寓辱，volatile讀插入內(nèi)存屏障后生產(chǎn)的指令序列示意圖：

image

上述volatile寫和volatile讀的內(nèi)存屏障插入策略非常保守。在實際執(zhí)行時赤拒，只要不改變volatile寫-讀的內(nèi)存語義秫筏，編譯器可以根據(jù)具體情況忽略不必要的屏障。在JMM基礎(chǔ)中就有提到過各個處理器對各個屏障的支持度挎挖，其中x86處理器僅會對寫-讀操作做重排序这敬。

下面我們通過具體的示例代碼來說明

class VolatileBarrierExample {
 int a;
 volatile int v1 = 1;
 volatile int v2 = 2;

 void readAndWrite() {
 int i = v1;           //第一個volatile讀
 int j = v2;           // 第二個volatile讀
 a = i + j;            //普通寫
 v1 = i + 1;          // 第一個volatile寫
 v2 = j * 2;          //第二個 volatile寫
 }

 …                    //其他方法
}

針對 readAndWrite() 方法，編譯器在生成字節(jié)碼時可以做如下的優(yōu)化：

image

注意蕉朵，最后的StoreLoad屏障不能省略崔涂。因為第二個volatile寫之后，方法立即return始衅。此時編譯器可能無法準(zhǔn)確斷定后面是否會有volatile讀或?qū)懤渎欤瑸榱税踩鹨姡幾g器常常會在這里插入一個StoreLoad屏障汛闸。

上面的優(yōu)化是針對任意處理器平臺蝙茶，由于不同的處理器有不同“松緊度”的處理器內(nèi)存模型，內(nèi)存屏障的插入還可以根據(jù)具體的處理器內(nèi)存模型繼續(xù)優(yōu)化诸老。以x86處理器為例隆夯，上圖中除最后的StoreLoad屏障外，其它的屏障都會被省略别伏。

前面保守策略下的volatile讀和寫蹄衷，在 x86處理器平臺可以優(yōu)化成：

image

前文提到過，x86 處理器僅會對寫 - 讀操作做重排序厘肮。愧口，x86處理器僅會對寫-讀操作做重排序。X86不會對讀-讀轴脐，讀-寫和寫-寫操作做重排序调卑，因此在x86處理器中會省略掉這三種操作類型對應(yīng)的內(nèi)存屏障。在x86中大咱，JMM僅需在volatile寫后面插入一個StoreLoad屏障即可正確實現(xiàn)volatile寫-讀的內(nèi)存語義恬涧。這意味著在x86處理器中，volatile寫的開銷比volatile讀的開銷會大很多（因為執(zhí)行StoreLoad屏障開銷會比較大）碴巾。

為什么要增強(qiáng)volatile的內(nèi)存語義

在 JSR-133 之前的舊 Java 內(nèi)存模型中溯捆，雖然不允許 volatile 變量之間重排序，但舊的 Java 內(nèi)存模型允許 volatile 變量與普通變量之間重排序。在舊的內(nèi)存模型中提揍，VolatileExample 示例程序可能被重排序成下列時序來執(zhí)行：

image

在舊的內(nèi)存模型中啤月，當(dāng) 1 和 2 之間沒有數(shù)據(jù)依賴關(guān)系時，1 和 2 之間就可能被重排序（3 和 4 類似）劳跃。其結(jié)果就是：讀線程 B 執(zhí)行 4 時谎仲，不一定能看到寫線程 A 在執(zhí)行 1 時對共享變量的修改。

因此在舊的內(nèi)存模型中 刨仑，volatile的寫-讀沒有鎖的釋放-獲所具有的內(nèi)存語義郑诺。為了提供一種比鎖更輕量級的線程之間通信的機(jī)制，JSR-133專家組決定增強(qiáng)volatile的內(nèi)存語義：嚴(yán)格限制編譯器和處理器對volatile變量與普通變量的重排序杉武，確保volatile的寫-讀和鎖的釋放-獲取一樣辙诞，具有相同的內(nèi)存語義。從編譯器重排序規(guī)則和處理器內(nèi)存屏障插入策略來看轻抱，只要volatile變量與普通變量之間的重排序可能會破壞volatile的內(nèi)存語意飞涂，這種重排序就會被編譯器重排序規(guī)則和處理器內(nèi)存屏障插入策略禁止。

由于volatile僅僅保證對單個volatile變量的讀/寫具有原子性祈搜，而鎖的互斥執(zhí)行的特性可以確保對整個臨界區(qū)代碼的執(zhí)行具有原子性较店。在功能上，鎖比volatile更強(qiáng)大夭问；在可伸縮性和執(zhí)行性能上泽西，volatile更有優(yōu)勢。如果讀者想在程序中用volatile代替監(jiān)視器鎖缰趋，請一定謹(jǐn)慎捧杉，具體細(xì)節(jié)請參閱參考Java理論與實踐：正確使用Volatile變量。