轉載 原文地址：http://www.cnblogs.com/dolphin0520/p/3920373.html

Java并發(fā)編程：volatile關鍵字解析

　　 volatile這個關鍵字可能很多朋友都聽說過贸宏，或許也都用過桨踪。在Java 5之前，它是一個備受爭議的關鍵字，因為在程序中使用它往往會導致出人意料的結果碌识。在Java 5之后魏蔗，volatile關鍵字才得以重獲生機。

　　volatile關鍵字雖然從字面上理解起來比較簡單驼卖，但是要用好不是一件容易的事情氨肌。由于volatile關鍵字是與Java的內存模型有關的，因此在講述volatile關鍵之前酌畜，我們先來了解一下與內存模型相關的概念和知識怎囚，然后分析了volatile關鍵字的實現原理，最后給出了幾個使用volatile關鍵字的場景桥胞。

　　以下是本文的目錄大綱：

　　一.內存模型的相關概念

　　二.并發(fā)編程中的三個概念

　　三.Java內存模型

　　四..深入剖析volatile關鍵字

　　五.使用volatile關鍵字的場景

　　若有不正之處請多多諒解恳守，并歡迎批評指正。

　　請尊重作者勞動成果贩虾，轉載請標明原文鏈接：

　　http://www.cnblogs.com/dolphin0520/p/3920373.html

一.內存模型的相關概念

　　大家都知道催烘，計算機在執(zhí)行程序時，每條指令都是在CPU中執(zhí)行的缎罢，而執(zhí)行指令過程中伊群，勢必涉及到數據的讀取和寫入。由于程序運行過程中的臨時數據是存放在主存（物理內存）當中的策精，這時就存在一個問題舰始，由于CPU執(zhí)行速度很快，而從內存讀取數據和向內存寫入數據的過程跟CPU執(zhí)行指令的速度比起來要慢的多咽袜，因此如果任何時候對數據的操作都要通過和內存的交互來進行丸卷，會大大降低指令執(zhí)行的速度。因此在CPU里面就有了高速緩存询刹。

　　也就是谜嫉，當程序在運行過程中，會將運算需要的數據從主存復制一份到CPU的高速緩存當中凹联，那么CPU進行計算時就可以直接從它的高速緩存讀取數據和向其中寫入數據沐兰，當運算結束之后廓脆，再將高速緩存中的數據刷新到主存當中芍耘。舉個簡單的例子隘谣，比如下面的這段代碼：

1i = i +?1;

?　　當線程執(zhí)行這個語句時，會先從主存當中讀取i的值芍躏，然后復制一份到高速緩存當中茁影，然后CPU執(zhí)行指令對i進行加1操作适刀，然后將數據寫入高速緩存踱葛，最后將高速緩存中i最新的值刷新到主存當中。

　　這個代碼在單線程中運行是沒有任何問題的春寿，但是在多線程中運行就會有問題了朗涩。在多核CPU中，每條線程可能運行于不同的CPU中绑改，因此每個線程運行時有自己的高速緩存（對單核CPU來說谢床，其實也會出現這種問題，只不過是以線程調度的形式來分別執(zhí)行的）厘线。本文我們以多核CPU為例识腿。

　　比如同時有2個線程執(zhí)行這段代碼，假如初始時i的值為0造壮，那么我們希望兩個線程執(zhí)行完之后i的值變?yōu)?渡讼。但是事實會是這樣嗎？

　　可能存在下面一種情況：初始時耳璧，兩個線程分別讀取i的值存入各自所在的CPU的高速緩存當中成箫，然后線程1進行加1操作，然后把i的最新值1寫入到內存旨枯。此時線程2的高速緩存當中i的值還是0蹬昌，進行加1操作之后，i的值為1攀隔，然后線程2把i的值寫入內存皂贩。

　　最終結果i的值是1，而不是2竞慢。這就是著名的緩存一致性問題先紫。通常稱這種被多個線程訪問的變量為共享變量治泥。

　　也就是說筹煮，如果一個變量在多個CPU中都存在緩存（一般在多線程編程時才會出現），那么就可能存在緩存不一致的問題居夹。

　　為了解決緩存不一致性問題败潦，通常來說有以下2種解決方法：

　　1）通過在總線加LOCK#鎖的方式

　　2）通過緩存一致性協議

　　這2種方式都是硬件層面上提供的方式。

　　在早期的CPU當中准脂，是通過在總線上加LOCK#鎖的形式來解決緩存不一致的問題劫扒。因為CPU和其他部件進行通信都是通過總線來進行的，如果對總線加LOCK#鎖的話狸膏，也就是說阻塞了其他CPU對其他部件訪問（如內存）沟饥，從而使得只能有一個CPU能使用這個變量的內存。比如上面例子中 如果一個線程在執(zhí)行 i = i +1，如果在執(zhí)行這段代碼的過程中贤旷，在總線上發(fā)出了LCOK#鎖的信號广料，那么只有等待這段代碼完全執(zhí)行完畢之后，其他CPU才能從變量i所在的內存讀取變量幼驶，然后進行相應的操作艾杏。這樣就解決了緩存不一致的問題。

　　但是上面的方式會有一個問題盅藻，由于在鎖住總線期間购桑，其他CPU無法訪問內存，導致效率低下氏淑。

　　所以就出現了緩存一致性協議勃蜘。最出名的就是Intel 的MESI協議，MESI協議保證了每個緩存中使用的共享變量的副本是一致的假残。它核心的思想是：當CPU寫數據時元旬，如果發(fā)現操作的變量是共享變量，即在其他CPU中也存在該變量的副本守问，會發(fā)出信號通知其他CPU將該變量的緩存行置為無效狀態(tài)匀归，因此當其他CPU需要讀取這個變量時，發(fā)現自己緩存中緩存該變量的緩存行是無效的耗帕，那么它就會從內存重新讀取穆端。

二.并發(fā)編程中的三個概念

　　在并發(fā)編程中，我們通常會遇到以下三個問題：原子性問題仿便，可見性問題体啰，有序性問題。我們先看具體看一下這三個概念：

1.原子性

　　原子性：即一個操作或者多個操作 要么全部執(zhí)行并且執(zhí)行的過程不會被任何因素打斷嗽仪，要么就都不執(zhí)行荒勇。

　　一個很經典的例子就是銀行賬戶轉賬問題：

　　比如從賬戶A向賬戶B轉1000元，那么必然包括2個操作：從賬戶A減去1000元闻坚，往賬戶B加上1000元沽翔。

　　試想一下，如果這2個操作不具備原子性窿凤，會造成什么樣的后果仅偎。假如從賬戶A減去1000元之后，操作突然中止雳殊。然后又從B取出了500元橘沥，取出500元之后，再執(zhí)行 往賬戶B加上1000元 的操作夯秃。這樣就會導致賬戶A雖然減去了1000元座咆，但是賬戶B沒有收到這個轉過來的1000元痢艺。

　　所以這2個操作必須要具備原子性才能保證不出現一些意外的問題。

　　同樣地反映到并發(fā)編程中會出現什么結果呢介陶？

　　舉個最簡單的例子腹备，大家想一下假如為一個32位的變量賦值過程不具備原子性的話，會發(fā)生什么后果斤蔓？

1i =?9;

?　　假若一個線程執(zhí)行到這個語句時植酥，我暫且假設為一個32位的變量賦值包括兩個過程：為低16位賦值，為高16位賦值弦牡。

　　那么就可能發(fā)生一種情況：當將低16位數值寫入之后友驮，突然被中斷，而此時又有一個線程去讀取i的值驾锰，那么讀取到的就是錯誤的數據卸留。

2.可見性

　　可見性是指當多個線程訪問同一個變量時，一個線程修改了這個變量的值椭豫，其他線程能夠立即看得到修改的值耻瑟。

　　舉個簡單的例子，看下面這段代碼：

1

2

3

4

5

6

//線程1執(zhí)行的代碼

int?i =?0;

i =?10;

//線程2執(zhí)行的代碼

j = i;

?　　假若執(zhí)行線程1的是CPU1赏酥，執(zhí)行線程2的是CPU2喳整。由上面的分析可知，當線程1執(zhí)行 i =10這句時裸扶，會先把i的初始值加載到CPU1的高速緩存中框都，然后賦值為10，那么在CPU1的高速緩存當中i的值變?yōu)?0了呵晨，卻沒有立即寫入到主存當中魏保。

　　此時線程2執(zhí)行 j = i，它會先去主存讀取i的值并加載到CPU2的緩存當中摸屠，注意此時內存當中i的值還是0谓罗，那么就會使得j的值為0，而不是10.

　　這就是可見性問題季二，線程1對變量i修改了之后檩咱，線程2沒有立即看到線程1修改的值。

3.有序性

　　有序性：即程序執(zhí)行的順序按照代碼的先后順序執(zhí)行戒傻。舉個簡單的例子税手，看下面這段代碼：

1

2

3

4

int?i =?0;??????????????

boolean?flag =?false;

i =?1;?//語句1??

flag =?true;?//語句2

?　　上面代碼定義了一個int型變量蜂筹，定義了一個boolean類型變量需纳，然后分別對兩個變量進行賦值操作。從代碼順序上看艺挪，語句1是在語句2前面的不翩，那么JVM在真正執(zhí)行這段代碼的時候會保證語句1一定會在語句2前面執(zhí)行嗎兵扬？不一定，為什么呢口蝠？這里可能會發(fā)生指令重排序（Instruction Reorder）器钟。

　　下面解釋一下什么是指令重排序，一般來說妙蔗，處理器為了提高程序運行效率傲霸，可能會對輸入代碼進行優(yōu)化，它不保證程序中各個語句的執(zhí)行先后順序同代碼中的順序一致眉反，但是它會保證程序最終執(zhí)行結果和代碼順序執(zhí)行的結果是一致的昙啄。

　　比如上面的代碼中，語句1和語句2誰先執(zhí)行對最終的程序結果并沒有影響寸五，那么就有可能在執(zhí)行過程中梳凛，語句2先執(zhí)行而語句1后執(zhí)行。

　　但是要注意梳杏，雖然處理器會對指令進行重排序韧拒，但是它會保證程序最終結果會和代碼順序執(zhí)行結果相同，那么它靠什么保證的呢十性？再看下面一個例子：

1

2

3

4

int?a =?10;?//語句1

int?r =?2;?//語句2

a = a +?3;?//語句3

r = a*a;?//語句4

?　　這段代碼有4個語句叛溢，那么可能的一個執(zhí)行順序是：

　　那么可不可能是這個執(zhí)行順序呢： 語句2?? 語句1??? 語句4?? 語句3

　　不可能，因為處理器在進行重排序時是會考慮指令之間的數據依賴性劲适，如果一個指令Instruction 2必須用到Instruction 1的結果雇初，那么處理器會保證Instruction 1會在Instruction 2之前執(zhí)行。

　　雖然重排序不會影響單個線程內程序執(zhí)行的結果减响，但是多線程呢靖诗？下面看一個例子：

1

2

3

4

5

6

7

8

9

//線程1:

context = loadContext();?//語句1

inited =?true;?//語句2

//線程2:

while(!inited ){

??sleep()

}

doSomethingwithconfig(context);

?　　上面代碼中，由于語句1和語句2沒有數據依賴性支示，因此可能會被重排序刊橘。假如發(fā)生了重排序，在線程1執(zhí)行過程中先執(zhí)行語句2颂鸿，而此是線程2會以為初始化工作已經完成促绵，那么就會跳出while循環(huán)，去執(zhí)行doSomethingwithconfig(context)方法嘴纺，而此時context并沒有被初始化败晴，就會導致程序出錯。

?　　從上面可以看出栽渴，指令重排序不會影響單個線程的執(zhí)行尖坤，但是會影響到線程并發(fā)執(zhí)行的正確性。

　　也就是說闲擦，要想并發(fā)程序正確地執(zhí)行慢味，必須要保證原子性场梆、可見性以及有序性。只要有一個沒有被保證纯路，就有可能會導致程序運行不正確或油。

三.Java內存模型

　　在前面談到了一些關于內存模型以及并發(fā)編程中可能會出現的一些問題。下面我們來看一下Java內存模型驰唬，研究一下Java內存模型為我們提供了哪些保證以及在java中提供了哪些方法和機制來讓我們在進行多線程編程時能夠保證程序執(zhí)行的正確性顶岸。

　　在Java虛擬機規(guī)范中試圖定義一種Java內存模型（Java Memory Model，JMM）來屏蔽各個硬件平臺和操作系統的內存訪問差異叫编，以實現讓Java程序在各種平臺下都能達到一致的內存訪問效果蜕琴。那么Java內存模型規(guī)定了哪些東西呢，它定義了程序中變量的訪問規(guī)則宵溅，往大一點說是定義了程序執(zhí)行的次序凌简。注意，為了獲得較好的執(zhí)行性能恃逻，Java內存模型并沒有限制執(zhí)行引擎使用處理器的寄存器或者高速緩存來提升指令執(zhí)行速度雏搂，也沒有限制編譯器對指令進行重排序。也就是說寇损，在java內存模型中凸郑，也會存在緩存一致性問題和指令重排序的問題。

　　Java內存模型規(guī)定所有的變量都是存在主存當中（類似于前面說的物理內存）矛市，每個線程都有自己的工作內存（類似于前面的高速緩存）芙沥。線程對變量的所有操作都必須在工作內存中進行，而不能直接對主存進行操作浊吏。并且每個線程不能訪問其他線程的工作內存而昨。

　　舉個簡單的例子：在java中，執(zhí)行下面這個語句：

1i? =?10;

?　　執(zhí)行線程必須先在自己的工作線程中對變量i所在的緩存行進行賦值操作找田，然后再寫入主存當中歌憨。而不是直接將數值10寫入主存當中。

　　那么Java語言 本身對 原子性墩衙、可見性以及有序性提供了哪些保證呢务嫡？

1.原子性

　　在Java中，對基本數據類型的變量的讀取和賦值操作是原子性操作漆改，即這些操作是不可被中斷的心铃，要么執(zhí)行，要么不執(zhí)行挫剑。

　　上面一句話雖然看起來簡單去扣，但是理解起來并不是那么容易∧核常看下面一個例子i：

　　請分析以下哪些操作是原子性操作：

1

2

3

4

x =?10;?//語句1

y = x;?//語句2

x++;?//語句3

x = x +?1;?//語句4

?　　咋一看厅篓，有些朋友可能會說上面的4個語句中的操作都是原子性操作秀存。其實只有語句1是原子性操作捶码，其他三個語句都不是原子性操作羽氮。

　　語句1是直接將數值10賦值給x，也就是說線程執(zhí)行這個語句的會直接將數值10寫入到工作內存中惫恼。

　　語句2實際上包含2個操作档押，它先要去讀取x的值，再將x的值寫入工作內存祈纯，雖然讀取x的值以及 將x的值寫入工作內存 這2個操作都是原子性操作令宿，但是合起來就不是原子性操作了。

　　同樣的腕窥，x++和 x = x+1包括3個操作：讀取x的值粒没，進行加1操作，寫入新的值簇爆。

?　　所以上面4個語句只有語句1的操作具備原子性癞松。

　　也就是說，只有簡單的讀取入蛆、賦值（而且必須是將數字賦值給某個變量响蓉，變量之間的相互賦值不是原子操作）才是原子操作。

　　不過這里有一點需要注意：在32位平臺下哨毁，對64位數據的讀取和賦值是需要通過兩個操作來完成的枫甲，不能保證其原子性。但是好像在最新的JDK中扼褪，JVM已經保證對64位數據的讀取和賦值也是原子性操作了想幻。

　　從上面可以看出，Java內存模型只保證了基本讀取和賦值是原子性操作话浇，如果要實現更大范圍操作的原子性举畸，可以通過synchronized和Lock來實現。由于synchronized和Lock能夠保證任一時刻只有一個線程執(zhí)行該代碼塊凳枝，那么自然就不存在原子性問題了抄沮，從而保證了原子性。

2.可見性

　　對于可見性岖瑰，Java提供了volatile關鍵字來保證可見性叛买。

　　當一個共享變量被volatile修飾時，它會保證修改的值會立即被更新到主存蹋订，當有其他線程需要讀取時率挣，它會去內存中讀取新值。

　　而普通的共享變量不能保證可見性露戒，因為普通共享變量被修改之后椒功，什么時候被寫入主存是不確定的捶箱，當其他線程去讀取時，此時內存中可能還是原來的舊值动漾，因此無法保證可見性丁屎。

　　另外，通過synchronized和Lock也能夠保證可見性旱眯，synchronized和Lock能保證同一時刻只有一個線程獲取鎖然后執(zhí)行同步代碼晨川，并且在釋放鎖之前會將對變量的修改刷新到主存當中。因此可以保證可見性删豺。

3.有序性

　　在Java內存模型中共虑，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到單線程程序的執(zhí)行呀页，卻會影響到多線程并發(fā)執(zhí)行的正確性妈拌。

　　在Java里面，可以通過volatile關鍵字來保證一定的“有序性”（具體原理在下一節(jié)講述）蓬蝶。另外可以通過synchronized和Lock來保證有序性尘分，很顯然，synchronized和Lock保證每個時刻是有一個線程執(zhí)行同步代碼疾党，相當于是讓線程順序執(zhí)行同步代碼音诫，自然就保證了有序性。

另外雪位，Java內存模型具備一些先天的“有序性”竭钝，即不需要通過任何手段就能夠得到保證的有序性，這個通常也稱為 happens-before 原則雹洗。如果兩個操作的執(zhí)行次序無法從happens-before原則推導出來香罐，那么它們就不能保證它們的有序性，虛擬機可以隨意地對它們進行重排序时肿。

　　下面就來具體介紹下happens-before原則（先行發(fā)生原則）：

程序次序規(guī)則：一個線程內庇茫，按照代碼順序，書寫在前面的操作先行發(fā)生于書寫在后面的操作

鎖定規(guī)則：一個unLock操作先行發(fā)生于后面對同一個鎖額lock操作

volatile變量規(guī)則：對一個變量的寫操作先行發(fā)生于后面對這個變量的讀操作

傳遞規(guī)則：如果操作A先行發(fā)生于操作B螃成，而操作B又先行發(fā)生于操作C旦签，則可以得出操作A先行發(fā)生于操作C

線程啟動規(guī)則：Thread對象的start()方法先行發(fā)生于此線程的每個一個動作

線程中斷規(guī)則：對線程interrupt()方法的調用先行發(fā)生于被中斷線程的代碼檢測到中斷事件的發(fā)生

線程終結規(guī)則：線程中所有的操作都先行發(fā)生于線程的終止檢測，我們可以通過Thread.join()方法結束寸宏、Thread.isAlive()的返回值手段檢測到線程已經終止執(zhí)行

對象終結規(guī)則：一個對象的初始化完成先行發(fā)生于他的finalize()方法的開始

　　這8條原則摘自《深入理解Java虛擬機》宁炫。

　　這8條規(guī)則中，前4條規(guī)則是比較重要的氮凝，后4條規(guī)則都是顯而易見的羔巢。

　　下面我們來解釋一下前4條規(guī)則：

　　對于程序次序規(guī)則來說，我的理解就是一段程序代碼的執(zhí)行在單個線程中看起來是有序的。注意竿秆，雖然這條規(guī)則中提到“書寫在前面的操作先行發(fā)生于書寫在后面的操作”启摄，這個應該是程序看起來執(zhí)行的順序是按照代碼順序執(zhí)行的，因為虛擬機可能會對程序代碼進行指令重排序幽钢。雖然進行重排序歉备，但是最終執(zhí)行的結果是與程序順序執(zhí)行的結果一致的，它只會對不存在數據依賴性的指令進行重排序搅吁。因此威创，在單個線程中落午，程序執(zhí)行看起來是有序執(zhí)行的谎懦，這一點要注意理解。事實上溃斋，這個規(guī)則是用來保證程序在單線程中執(zhí)行結果的正確性界拦，但無法保證程序在多線程中執(zhí)行的正確性。

　　第二條規(guī)則也比較容易理解梗劫，也就是說無論在單線程中還是多線程中享甸，同一個鎖如果出于被鎖定的狀態(tài)，那么必須先對鎖進行了釋放操作梳侨，后面才能繼續(xù)進行l(wèi)ock操作蛉威。

　　第三條規(guī)則是一條比較重要的規(guī)則，也是后文將要重點講述的內容走哺。直觀地解釋就是蚯嫌，如果一個線程先去寫一個變量，然后一個線程去進行讀取丙躏，那么寫入操作肯定會先行發(fā)生于讀操作择示。

　　第四條規(guī)則實際上就是體現happens-before原則具備傳遞性。

四.深入剖析volatile關鍵字

　　在前面講述了很多東西晒旅，其實都是為講述volatile關鍵字作鋪墊栅盲，那么接下來我們就進入主題。

1.volatile關鍵字的兩層語義

　　一旦一個共享變量（類的成員變量废恋、類的靜態(tài)成員變量）被volatile修飾之后谈秫，那么就具備了兩層語義：

　　1）保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值鱼鼓，這新值對其他線程來說是立即可見的拟烫。

　　2）禁止進行指令重排序。

　　先看一段代碼蚓哩，假如線程1先執(zhí)行构灸，線程2后執(zhí)行：

1

2

3

4

5

6

7

8

//線程1

boolean?stop =?false;

while(!stop){

????doSomething();

}

//線程2

stop =?true;

?　　這段代碼是很典型的一段代碼，很多人在中斷線程時可能都會采用這種標記辦法。但是事實上喜颁，這段代碼會完全運行正確么稠氮？即一定會將線程中斷么？不一定半开，也許在大多數時候隔披，這個代碼能夠把線程中斷，但是也有可能會導致無法中斷線程（雖然這個可能性很小寂拆，但是只要一旦發(fā)生這種情況就會造成死循環(huán)了）奢米。

　　下面解釋一下這段代碼為何有可能導致無法中斷線程。在前面已經解釋過纠永，每個線程在運行過程中都有自己的工作內存鬓长，那么線程1在運行的時候，會將stop變量的值拷貝一份放在自己的工作內存當中尝江。

　　那么當線程2更改了stop變量的值之后涉波，但是還沒來得及寫入主存當中，線程2轉去做其他事情了炭序，那么線程1由于不知道線程2對stop變量的更改啤覆，因此還會一直循環(huán)下去。

　　但是用volatile修飾之后就變得不一樣了：

　　第一：使用volatile關鍵字會強制將修改的值立即寫入主存惭聂；

　　第二：使用volatile關鍵字的話窗声，當線程2進行修改時，會導致線程1的工作內存中緩存變量stop的緩存行無效（反映到硬件層的話辜纲，就是CPU的L1或者L2緩存中對應的緩存行無效）笨觅；

　　第三：由于線程1的工作內存中緩存變量stop的緩存行無效，所以線程1再次讀取變量stop的值時會去主存讀取侨歉。

　　那么在線程2修改stop值時（當然這里包括2個操作屋摇，修改線程2工作內存中的值，然后將修改后的值寫入內存）幽邓，會使得線程1的工作內存中緩存變量stop的緩存行無效炮温，然后線程1讀取時肩狂，發(fā)現自己的緩存行無效局待，它會等待緩存行對應的主存地址被更新之后，然后去對應的主存讀取最新的值龄砰。

　　那么線程1讀取到的就是最新的正確的值畸颅。

2.volatile保證原子性嗎担巩？

　　從上面知道volatile關鍵字保證了操作的可見性，但是volatile能保證對變量的操作是原子性嗎没炒？

　　下面看一個例子：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

public?class?Test {

????public?volatile?int?inc =?0;

????public?void?increase() {

????????inc++;

????}

????public?static?void?main(String[] args) {

????????final?Test test =?new?Test();

????????for(int?i=0;i<10;i++){

????????????new?Thread(){

????????????????public?void?run() {

????????????????????for(int?j=0;j<1000;j++)

????????????????????????test.increase();

????????????????};

????????????}.start();

????????}

????????while(Thread.activeCount()>1)?//保證前面的線程都執(zhí)行完

????????????Thread.yield();

????????System.out.println(test.inc);

????}

}

?　　大家想一下這段程序的輸出結果是多少涛癌？也許有些朋友認為是10000。但是事實上運行它會發(fā)現每次運行結果都不一致，都是一個小于10000的數字拳话。

　　可能有的朋友就會有疑問先匪，不對啊，上面是對變量inc進行自增操作弃衍，由于volatile保證了可見性呀非，那么在每個線程中對inc自增完之后，在其他線程中都能看到修改后的值啊镜盯，所以有10個線程分別進行了1000次操作岸裙，那么最終inc的值應該是1000*10=10000。

　　這里面就有一個誤區(qū)了速缆，volatile關鍵字能保證可見性沒有錯降允，但是上面的程序錯在沒能保證原子性〖さ樱可見性只能保證每次讀取的是最新的值拟糕，但是volatile沒辦法保證對變量的操作的原子性判呕。

　　在前面已經提到過倦踢，自增操作是不具備原子性的，它包括讀取變量的原始值侠草、進行加1操作辱挥、寫入工作內存。那么就是說自增操作的三個子操作可能會分割開執(zhí)行边涕，就有可能導致下面這種情況出現：

　　假如某個時刻變量inc的值為10晤碘，

　　線程1對變量進行自增操作，線程1先讀取了變量inc的原始值功蜓，然后線程1被阻塞了园爷；

　　然后線程2對變量進行自增操作，線程2也去讀取變量inc的原始值式撼，由于線程1只是對變量inc進行讀取操作童社，而沒有對變量進行修改操作，所以不會導致線程2的工作內存中緩存變量inc的緩存行無效著隆，所以線程2會直接去主存讀取inc的值扰楼，發(fā)現inc的值時10，然后進行加1操作美浦，并把11寫入工作內存弦赖，最后寫入主存。

　　然后線程1接著進行加1操作浦辨，由于已經讀取了inc的值蹬竖，注意此時在線程1的工作內存中inc的值仍然為10，所以線程1對inc進行加1操作后inc的值為11，然后將11寫入工作內存币厕，最后寫入主存庆冕。

　　那么兩個線程分別進行了一次自增操作后，inc只增加了1劈榨。

　　解釋到這里访递，可能有朋友會有疑問，不對啊同辣，前面不是保證一個變量在修改volatile變量時拷姿，會讓緩存行無效嗎？然后其他線程去讀就會讀到新的值旱函，對响巢，這個沒錯。這個就是上面的happens-before規(guī)則中的volatile變量規(guī)則棒妨，但是要注意踪古，線程1對變量進行讀取操作之后，被阻塞了的話券腔，并沒有對inc值進行修改伏穆。然后雖然volatile能保證線程2對變量inc的值讀取是從內存中讀取的，但是線程1沒有進行修改纷纫，所以線程2根本就不會看到修改的值枕扫。

　　根源就在這里，自增操作不是原子性操作辱魁，而且volatile也無法保證對變量的任何操作都是原子性的烟瞧。

　　把上面的代碼改成以下任何一種都可以達到效果：

　　采用synchronized：

publicclass Test {

? ? publicintinc = 0;

? ? publicsynchronizedvoid increase() {

? ? ? ? inc++;

? ? }

? ? publicstaticvoid main(String[] args) {

? ? ? ? finalTest test =new Test();

? ? ? ? for(inti=0;i<10;i++){

? ? ? ? ? ? new Thread(){

? ? ? ? ? ? ? ? publicvoid run() {

? ? ? ? ? ? ? ? ? ? for(intj=0;j<1000;j++)

? ? ? ? ? ? ? ? ? ? ? ? test.increase();

? ? ? ? ? ? ? ? };

? ? ? ? ? ? }.start();

? ? ? ? }

? ? ? ? while(Thread.activeCount()>1)//保證前面的線程都執(zhí)行完? ? ? ? ? ? Thread.yield();

? ? ? ? System.out.println(test.inc);

? ? }

}

　　采用Lock：

publicclass Test {

? ? publicintinc = 0;

? ? Lock lock =new ReentrantLock();

? ? publicvoid increase() {

? ? ? ? lock.lock();

? ? ? ? try {

? ? ? ? ? ? inc++;

? ? ? ? } finally{

? ? ? ? ? ? lock.unlock();

? ? ? ? }

? ? }

? ? publicstaticvoid main(String[] args) {

? ? ? ? finalTest test =new Test();

? ? ? ? for(inti=0;i<10;i++){

? ? ? ? ? ? new Thread(){

? ? ? ? ? ? ? ? publicvoid run() {

? ? ? ? ? ? ? ? ? ? for(intj=0;j<1000;j++)

? ? ? ? ? ? ? ? ? ? ? ? test.increase();

? ? ? ? ? ? ? ? };

? ? ? ? ? ? }.start();

? ? ? ? }

? ? ? ? while(Thread.activeCount()>1)//保證前面的線程都執(zhí)行完? ? ? ? ? ? Thread.yield();

? ? ? ? System.out.println(test.inc);

? ? }

}

　　采用AtomicInteger：

publicclass Test {

? ? publicAtomicInteger inc =new AtomicInteger();

? ? publicvoid increase() {

? ? ? ? inc.getAndIncrement();

? ? }

? ? publicstaticvoid main(String[] args) {

? ? ? ? finalTest test =new Test();

? ? ? ? for(inti=0;i<10;i++){

? ? ? ? ? ? new Thread(){

? ? ? ? ? ? ? ? publicvoid run() {

? ? ? ? ? ? ? ? ? ? for(intj=0;j<1000;j++)

? ? ? ? ? ? ? ? ? ? ? ? test.increase();

? ? ? ? ? ? ? ? };

? ? ? ? ? ? }.start();

? ? ? ? }

? ? ? ? while(Thread.activeCount()>1)//保證前面的線程都執(zhí)行完? ? ? ? ? ? Thread.yield();

? ? ? ? System.out.println(test.inc);

? ? }

}

　　在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作類，即對基本數據類型的 自增（加1操作）染簇，自減（減1操作）参滴、以及加法操作（加一個數），減法操作（減一個數）進行了封裝锻弓，保證這些操作是原子性操作砾赔。atomic是利用CAS來實現原子性操作的（Compare And Swap），CAS實際上是利用處理器提供的CMPXCHG指令實現的弥咪，而處理器執(zhí)行CMPXCHG指令是一個原子性操作过蹂。

3.volatile能保證有序性嗎？

　　在前面提到volatile關鍵字能禁止指令重排序聚至，所以volatile能在一定程度上保證有序性酷勺。

　　volatile關鍵字禁止指令重排序有兩層意思：

　　1）當程序執(zhí)行到volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行扳躬，且結果已經對后面的操作可見脆诉；在其后面的操作肯定還沒有進行甚亭；

　　2）在進行指令優(yōu)化時，不能將在對volatile變量訪問的語句放在其后面執(zhí)行击胜，也不能把volatile變量后面的語句放到其前面執(zhí)行亏狰。

　　可能上面說的比較繞，舉個簡單的例子：

1

2

3

4

5

6

7

8

//x偶摔、y為非volatile變量

//flag為volatile變量

x =?2;?//語句1

y =?0;?//語句2

flag =?true;?//語句3

x =?4;?//語句4

y = -1;?//語句5

?　　由于flag變量為volatile變量暇唾，那么在進行指令重排序的過程的時候，不會將語句3放到語句1辰斋、語句2前面策州，也不會講語句3放到語句4、語句5后面宫仗。但是要注意語句1和語句2的順序够挂、語句4和語句5的順序是不作任何保證的。

　　并且volatile關鍵字能保證藕夫，執(zhí)行到語句3時孽糖，語句1和語句2必定是執(zhí)行完畢了的，且語句1和語句2的執(zhí)行結果對語句3毅贮、語句4办悟、語句5是可見的。

　　那么我們回到前面舉的一個例子：

1

2

3

4

5

6

7

8

9

//線程1:

context = loadContext();?//語句1

inited =?true;?//語句2

//線程2:

while(!inited ){

??sleep()

}

doSomethingwithconfig(context);

?　　前面舉這個例子的時候嫩码，提到有可能語句2會在語句1之前執(zhí)行誉尖，那么久可能導致context還沒被初始化，而線程2中就使用未初始化的context去進行操作铸题，導致程序出錯。

　　這里如果用volatile關鍵字對inited變量進行修飾琢感，就不會出現這種問題了丢间，因為當執(zhí)行到語句2時，必定能保證context已經初始化完畢驹针。

4.volatile的原理和實現機制

　　前面講述了源于volatile關鍵字的一些使用烘挫，下面我們來探討一下volatile到底如何保證可見性和禁止指令重排序的。

　　下面這段話摘自《深入理解Java虛擬機》：

　　“觀察加入volatile關鍵字和沒有加入volatile關鍵字時所生成的匯編代碼發(fā)現柬甥，加入volatile關鍵字時饮六，會多出一個lock前綴指令”

　　lock前綴指令實際上相當于一個內存屏障（也成內存柵欄），內存屏障會提供3個功能：

　　1）它確保指令重排序時不會把其后面的指令排到內存屏障之前的位置苛蒲，也不會把前面的指令排到內存屏障的后面卤橄；即在執(zhí)行到內存屏障這句指令時，在它前面的操作已經全部完成臂外；

　　2）它會強制將對緩存的修改操作立即寫入主存窟扑；

　　3）如果是寫操作喇颁，它會導致其他CPU中對應的緩存行無效。

五.使用volatile關鍵字的場景

　　synchronized關鍵字是防止多個線程同時執(zhí)行一段代碼嚎货，那么就會很影響程序執(zhí)行效率橘霎，而volatile關鍵字在某些情況下性能要優(yōu)于synchronized，但是要注意volatile關鍵字是無法替代synchronized關鍵字的殖属，因為volatile關鍵字無法保證操作的原子性姐叁。通常來說，使用volatile必須具備以下2個條件：

　　1）對變量的寫操作不依賴于當前值

　　2）該變量沒有包含在具有其他變量的不變式中

　　實際上洗显，這些條件表明七蜘，可以被寫入 volatile 變量的這些有效值獨立于任何程序的狀態(tài)，包括變量的當前狀態(tài)墙懂。

　　事實上橡卤，我的理解就是上面的2個條件需要保證操作是原子性操作，才能保證使用volatile關鍵字的程序在并發(fā)時能夠正確執(zhí)行损搬。

　　下面列舉幾個Java中使用volatile的幾個場景碧库。

1.狀態(tài)標記量

1

2

3

4

5

6

7

8

9

volatile?boolean?flag =?false;

while(!flag){

????doSomething();

}

public?void?setFlag() {

????flag =?true;

}

1

2

3

4

5

6

7

8

9

10

volatile?boolean?inited =?false;

//線程1:

context = loadContext();??

inited =?true;????????????

//線程2:

while(!inited ){

sleep()

}

doSomethingwithconfig(context);

2.double check

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

class?Singleton{

????private?volatile?static?Singleton instance =?null;

????private?Singleton() {

????}

????public?static?Singleton getInstance() {

????????if(instance==null) {

????????????synchronized?(Singleton.class) {

????????????????if(instance==null)

????????????????????instance =?new?Singleton();

????????????}

????????}

????????return?instance;

????}

}