JAVA CAS原理

 

轉自：

 

　　http://blog.csdn.net/hsuxu/article/details/9467651

 

 

CAS

　　CAS: Compare and Swap

　　java.util.concurrent包中藉助CAS實現了區別於synchronouse同步鎖的一種樂觀鎖。

　　CAS 指的是現代 CPU 普遍支持的一種對內存中的共享數據進行操做的一種特殊指令。這個指令會對內存中的共享數據作原子的讀寫操做。簡 單介紹一下這個指令的操做過程：首先，CPU 會將內存中將要被更改的數據與指望的值作比較。而後，當這兩個值相等時，CPU 纔會將內存中的數值替換爲新的值。不然便不作操做。最後，CPU 會將舊的數值返回。這一系列的操做是原子的。它們雖然看似複雜，但倒是 Java 5 併發機制優於原有鎖機制的根本。簡單來講，CAS 的含義是「我認爲原有的值應該是什麼，若是是，則將原有的值更新爲新值，不然不作修改，並告訴我原來的值是多少」。（這段描述引自《Java併發編程實踐》）
       簡單的來講，CAS有3個操做數，內存值V，舊的預期值A，要修改的新值B。當且僅當預期值A和內存值V相同時，將內存值V修改成B，不然返回V。這是一種樂觀鎖的思路，它相信在它修改以前，沒有其它線程去修改它；而Synchronized是一種悲觀鎖，它認爲在它修改以前，必定會有其它線程去修改它，悲觀鎖效率很低。

 

CAS應用

　　CAS有3個操做數，內存值V，舊的預期值A，要修改的新值B。當且僅當預期值A和內存值V相同時，將內存值V修改成B，不然什麼都不作。

 

非阻塞算法 （nonblocking algorithms）

　　一個線程的失敗或者掛起不該該影響其餘線程的失敗或掛起的算法。

 

現代的CPU提供了特殊的指令，能夠自動更新共享數據，並且可以檢測到其餘線程的干擾，而 compareAndSet() 就用這些代替了鎖定。

拿出AtomicInteger來研究在沒有鎖的狀況下是如何作到數據正確性的。

1 private volatile int value;

首先毫無覺得，在沒有鎖的機制下可能須要藉助volatile原語，保證線程間的數據是可見的（共享的）。

這樣才獲取變量的值的時候才能直接讀取。

1 public final int get() {
2         return value;
3 }

 

而後來看看++i是怎麼作到的。

1 public final int incrementAndGet() {
2     for (;;) {
3         int current = get();
4         int next = current + 1;
5         if (compareAndSet(current, next))
6             return next;
7     }
8 }

 

在這裏採用了CAS操做，每次從內存中讀取數據而後將此數據和+1後的結果進行CAS操做，若是成功就返回結果，不然重試直到成功爲止。

而compareAndSet利用JNI來完成CPU指令的操做。

1 public final boolean compareAndSet(int expect, int update) {   
2     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
3 }

總體的過程就是這樣子的，利用CPU的CAS指令，同時藉助JNI來完成Java的非阻塞算法。其它原子操做都是利用相似的特性完成的。

 

其中 unsafe.compareAndSwapInt(this, valueOffset, expect, update); 相似：

1 if (this == expect) {
2   this = update;
3   return true;
4 } else {
5   return false;
6 }

那麼問題就來了，成功過程當中須要2個步驟：比較this == expect，替換this = update，compareAndSwapInt如何這兩個步驟的原子性呢？ 參考CAS的原理。

 

CAS原理

　　CAS經過調用JNI的代碼實現的。JNI:Java Native Interface爲JAVA本地調用，容許java調用其餘語言。

　　而compareAndSwapInt就是藉助C來調用CPU底層指令實現的。

下面從分析比較經常使用的CPU（intel x86）來解釋CAS的實現原理。

下面是sun.misc.Unsafe類的compareAndSwapInt()方法的源代碼：

public final native boolean compareAndSwapInt(Object o, long offset,
                                              int expected,
                                              int x);

 

能夠看到這是個本地方法調用。這個本地方法在openjdk中依次調用的c++代碼爲：unsafe.cpp，atomic.cpp和atomicwindowsx86.inline.hpp。這個本地方法的最終實如今openjdk的以下位置：openjdk-7-fcs-src-b147-27jun2011\openjdk\hotspot\src\oscpu\windowsx86\vm\ atomicwindowsx86.inline.hpp（對應於windows操做系統，X86處理器）。下面是對應於intel x86處理器的源代碼的片斷：

 

 1 // Adding a lock prefix to an instruction on MP machine
 2 // VC++ doesn't like the lock prefix to be on a single line
 3 // so we can't insert a label after the lock prefix.
 4 // By emitting a lock prefix, we can define a label after it.
 5 #define LOCK_IF_MP(mp) __asm cmp mp, 0  \
 6                        __asm je L0      \
 7                        __asm _emit 0xF0 \
 8                        __asm L0:
 9 
10 inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
11   // alternative for InterlockedCompareExchange
12   int mp = os::is_MP();
13   __asm {
14     mov edx, dest
15     mov ecx, exchange_value
16     mov eax, compare_value
17     LOCK_IF_MP(mp)
18     cmpxchg dword ptr [edx], ecx
19   }
20 }

View Code

 

如上面源代碼所示，程序會根據當前處理器的類型來決定是否爲cmpxchg指令添加lock前綴。若是程序是在多處理器上運行，就爲cmpxchg指令加 上lock前綴（lock cmpxchg）。反之，若是程序是在單處理器上運行，就省略lock前綴（單處理器自身會維護單處理器內的順序一致性，不須要lock前綴提供的內存屏 障效果）。

 

 intel的手冊對lock前綴的說明以下：

1. 確保對內存的讀-改-寫操做原子執行。在Pentium及Pentium以前的處理器中，帶有lock前綴的指令在執行期間會鎖住總線，使得其餘 處理器暫時沒法經過總線訪問內存。很顯然，這會帶來昂貴的開銷。從Pentium 4，Intel Xeon及P6處理器開始，intel在原有總線鎖的基礎上作了一個頗有意義的優化：若是要訪問的內存區域（area of memory）在lock前綴指令執行期間已經在處理器內部的緩存中被鎖定（即包含該內存區域的緩存行當前處於獨佔或以修改狀態），而且該內存區域被徹底 包含在單個緩存行（cache line）中，那麼處理器將直接執行該指令。因爲在指令執行期間該緩存行會一直被鎖定，其它處理器沒法讀/寫該指令要訪問的內存區域，所以能保證指令執行 的原子性。這個操做過程叫作緩存鎖定（cache locking），緩存鎖定將大大下降lock前綴指令的執行開銷，可是當多處理器之間的競爭程度很高或者指令訪問的內存地址未對齊時，仍然會鎖住總線。
2. 禁止該指令與以前和以後的讀和寫指令重排序。
3. 把寫緩衝區中的全部數據刷新到內存中。

 

備註知識：

關於CPU的鎖有以下3種：

　　3.1 處理器自動保證基本內存操做的原子性

　　首先處理器會自動保證基本的內存操做的原子性。處理器保證從系統內存當中讀取或者寫入一個字節 是原子的，意思是當一個處理器讀取一個字節時，其餘處理器不能訪問這個字節的內存地址。奔騰6和最新的處理器能自動保證單處理器對同一個緩存行裏進行 16/32/64位的操做是原子的，可是複雜的內存操做處理器不能自動保證其原子性，好比跨總線寬度，跨多個緩存行，跨頁表的訪問。可是處理器提供總線鎖 定和緩存鎖定兩個機制來保證複雜內存操做的原子性。 

　　3.2 使用總線鎖保證原子性

　　第一個機制是經過總線鎖保證原子性。若是多個處理器同時對共享變量進行讀改寫（i++就是經典的讀改寫操做）操做，那麼共享變量就會被多個處理 器同時進行操做，這樣讀改寫操做就不是原子的，操做完以後共享變量的值會和指望的不一致，舉個例子：若是i=1,咱們進行兩次i++操做，咱們指望的結果 是3，可是有可能結果是2。以下圖

 

 

　　緣由是有可能多個處理器同時從各自的緩存中讀取變量i，分別進行加一操做，而後分別寫入系統內存當中。那麼想要保證讀改寫共享變量的操做是原子的，就必須保證CPU1讀改寫共享變量的時候，CPU2不能操做緩存了該共享變量內存地址的緩存。

　　處理器使用總線鎖就是來解決這個問題的。所謂總線鎖就是使用處理器提供的一個LOCK＃信號，當一個處理器在總線上輸出此信號時，其餘處理器的請求將被阻塞住,那麼該處理器能夠獨佔使用共享內存。

　　3.3 使用緩存鎖保證原子性

　　第二個機制是經過緩存鎖定保證原子性。在同一時刻 咱們只需保證對某個內存地址的操做是原子性便可，但總線鎖定把CPU和內存之間通訊鎖住了，這使得鎖按期間，其餘處理器不能操做其餘內存地址的數據，因此 總線鎖定的開銷比較大，最近的處理器在某些場合下使用緩存鎖定代替總線鎖定來進行優化。

　　頻繁使用的內存會緩存在處理器的L1，L2和L3 高速緩存裏，那麼原子操做就能夠直接在處理器內部緩存中進行，並不須要聲明總線鎖，在奔騰6和最近的處理器中可使用「緩存鎖定」的方式來實現複雜的原子 性。所謂「緩存鎖定」就是若是緩存在處理器緩存行中內存區域在LOCK操做期間被鎖定，當它執行鎖操做回寫內存時，處理器不在總線上聲言LOCK＃信號， 而是修改內部的內存地址，並容許它的緩存一致性機制來保證操做的原子性，由於緩存一致性機制會阻止同時修改被兩個以上處理器緩存的內存區域數據，當其餘處 理器回寫已被鎖定的緩存行的數據時會起緩存行無效，在例1中，當CPU1修改緩存行中的i時使用緩存鎖定，那麼CPU2就不能同時緩存了i的緩存行。

　　可是有兩種狀況下處理器不會使用緩存鎖定。第一種 狀況是：當操做的數據不能被緩存在處理器內部，或操做的數據跨多個緩存行（cache line），則處理器會調用總線鎖定。第二種狀況是：有些處理器不支持緩存鎖定。對於Inter486和奔騰處理器,就算鎖定的內存區域在處理器的緩存行 中也會調用總線鎖定。

　　以上兩個機制咱們能夠經過Inter處理器提供了 不少LOCK前綴的指令來實現。好比位測試和修改指令BTS，BTR，BTC，交換指令XADD，CMPXCHG和其餘一些操做數和邏輯指令，好比 ADD（加），OR（或）等，被這些指令操做的內存區域就會加鎖，致使其餘處理器不能同時訪問它。

 

CAS缺點

 CAS雖然很高效的解決原子操做，可是CAS仍然存在三大問題。ABA問題，循環時間長開銷大和只能保證一個共享變量的原子操做

1.  ABA問題。 由於CAS須要在操做值的時候檢查下值有沒有發生變化，若是沒有發生變化則更新，可是若是一個值原來是A，變成了B，又變成了A，那麼使用CAS進行檢查 時會發現它的值沒有發生變化，可是實際上卻變化了。ABA問題的解決思路就是使用版本號。在變量前面追加上版本號，每次變量更新的時候把版本號加一，那麼 A－B－A 就會變成1A-2B－3A。

從Java1.5 開始JDK的atomic包裏提供了一個類AtomicStampedReference來解決ABA問題。這個類的compareAndSet方法做用 是首先檢查當前引用是否等於預期引用，而且當前標誌是否等於預期標誌，若是所有相等，則以原子方式將該引用和該標誌的值設置爲給定的更新值。

關於ABA問題參考文檔: http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedreference.html

2. 循環時間長開銷大。 自旋CAS若是長時間不成功，會給CPU帶來很是大的執行開銷。若是JVM能支持處理器提供的pause指令那麼效率會有必定的提高，pause指令有兩 個做用，第一它能夠延遲流水線執行指令（de-pipeline）,使CPU不會消耗過多的執行資源，延遲的時間取決於具體實現的版本，在一些處理器上延 遲時間是零。第二它能夠避免在退出循環的時候因內存順序衝突（memory order violation）而引發CPU流水線被清空（CPU pipeline flush），從而提升CPU的執行效率。

 

3. 只能保證一個共享變量的原子操做。 當對一個共享變量執行操做時，咱們可使用循環CAS的方式來保證原子操做，可是對多個共享變量操做時，循環CAS就沒法保證操做的原子性，這個時候就可 以用鎖，或者有一個取巧的辦法，就是把多個共享變量合併成一個共享變量來操做。好比有兩個共享變量i＝2,j=a，合併一下ij=2a，而後用CAS來操 做ij。從Java1.5開始JDK提供了AtomicReference類來保證引用對象之間的原子性，你能夠把多個變量放在一個對象裏來進行CAS操做。

 

 

concurrent包的實現

因爲java的CAS同時具備 volatile 讀和volatile寫的內存語義，所以Java線程之間的通訊如今有了下面四種方式：

1. A線程寫volatile變量，隨後B線程讀這個volatile變量。
2. A線程寫volatile變量，隨後B線程用CAS更新這個volatile變量。
3. A線程用CAS更新一個volatile變量，隨後B線程用CAS更新這個volatile變量。
4. A線程用CAS更新一個volatile變量，隨後B線程讀這個volatile變量。

Java的CAS會使用現代處理器上提供的高效機器級別原子指令，這些原子指令以原子方式對內存執行讀-改-寫操做，這是在多處理器中實現同步的關鍵（從 本質上來講，可以支持原子性讀-改-寫指令的計算機器，是順序計算圖靈機的異步等價機器，所以任何現代的多處理器都會去支持某種能對內存執行原子性讀-改 -寫操做的原子指令）。同時，volatile變量的讀/寫和CAS能夠實現線程之間的通訊。把這些特性整合在一塊兒，就造成了整個concurrent包 得以實現的基石。若是咱們仔細分析concurrent包的源代碼實現，會發現一個通用化的實現模式：

1. 首先，聲明共享變量爲volatile；
2. 而後，使用CAS的原子條件更新來實現線程之間的同步；
3. 同時，配合以volatile的讀/寫和CAS所具備的volatile讀和寫的內存語義來實現線程之間的通訊。

AQS，非阻塞數據結構和原子變量類（java.util.concurrent.atomic包中的類），這些concurrent包中的基礎類都是使 用這種模式來實現的，而concurrent包中的高層類又是依賴於這些基礎類來實現的。從總體來看，concurrent包的實現示意圖以下：