Java中volatile++不是原子性的原因是什么

這篇文章給大家介紹Java中volatile++不是原子性的原因是什么，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

因為它實際上是三個操作組成的一個符合操作。

1. 首先獲取volatile變量的值

2. 將該變量的值加1

3. 將該volatile變量的值寫會到對應的主存地址
   

一個很簡單的例子：

如果兩個線程在volatile讀階段都拿到的是a=1，那么后續(xù)在線程對應的CPU核心上進行自增當然都得到的是a=2，最后兩個寫操作不管怎么保證原子性，結果最終都是a=2。每個操作本身都沒啥問題，但是合在一起，從整體上看就是一個線程不安全的操作：發(fā)生了兩次自增操作，然而最終結果卻不是3。

分析

結合內存屏障這個概念對volatile的讀寫操作深入理解的話：

第一步：讀

在第一步操作的指令后，會增加兩個內存屏障：

1. 在Volatile讀操作后插入LoadLoad屏障，防止前面的Volatile讀與后面的普通讀重排序

2. 在Volatile讀操作后插入LoadStore屏障，防止前面的Volatile讀與后面的普通寫重排序
   

因此第一個指令和它后續(xù)的普通讀寫操作會被保證沒有重排序來搗亂。通常是去內存中去讀。

那么問題又來了，為什么通常去內存中讀？

其實這個問題要說細的話可以很細，大概就兩個關鍵點吧：

1. volatile的寫操作的緩存失效機制

2. 最后一個對volatile變量執(zhí)行寫操作的CPU，由于在它對應的緩存中保有最新的值，因此可以不用再去主存里面獲取
   

具體看下面第三步的分析。

第二步：自增

這個步驟沒什么特別的，就是在CPU自身的高速緩存(寄存器，L1-L3 Cache)中完成。不涉及到緩存和內存的交互。

第三步：寫

volatile寫算是一個重點。

根據JMM對于volatile變量類型的語義規(guī)范：volatile在編譯之后，會在變量寫操作時添加LOCK前綴指令。這個LOCK前綴指令在多核處理器的環(huán)境中，有這樣的作用：

1. 通知CPU將當前處理器緩存行的數據寫回到系統(tǒng)主存中

2. 該寫回操作將使其他CPU緩存了該內存地址的數據無效
   

另外，內存屏障在volatile的寫操作中起到了很大的作用，來保證上面兩點能夠實現：

1. 在Volatile寫操作前插入StoreStore屏障，防止前面其他寫與本次Volatile寫重排序

2. 在Volatile寫操作后插入StoreLoad屏障，防止本次的Volatile寫與后面的讀操作重排序
   

延伸

那么為了解決volatile++這類復合操作的原子性，有什么方案呢？其實方案也比較多的，這里提供兩種典型的：

1. 使用synchronized關鍵字

2. 使用AtomicInteger/AtomicLong原子類型
   

synchronized關鍵字

synchronized是比較原始的同步手段。它本質上是一個獨占的，可重入的鎖。當一個線程嘗試獲取它的時候，可能會被阻塞住，所以高并發(fā)的場景下性能存在一些問題。

在某些場景下，使用synchronized關鍵字和volatile是等價的：

1. 寫入變量值時候不依賴變量的當前值，或者能夠保證只有一個線程修改變量值。

2. 寫入的變量值不依賴其他變量的參與。

3. 讀取變量值時候不能因為其他原因進行加鎖。
   

加鎖可以同時保證可見性和原子性，而volatile只保證變量值的可見性。

AtomicInteger/AtomicLong

這類原子類型比鎖更加輕巧，比如AtomicInteger/AtomicLong分別就代表了整型變量和長整型變量。

在它們的實現中，實際上分別使用的volatile int/volatile long保存了真正的值。因此，也是通過volatile來保證對于單個變量的讀寫原子性的。

在此基礎之上，它們提供了原子性的自增自減操作。比如incrementAndGet方法，這類方法相對于synchronized的好處是：它們不會導致線程的掛起和重新調度，因為在其內部使用的是CAS非阻塞算法。

CAS是什么

所謂的CAS全程為CompareAndSet。直譯過來就是比較并設置。這個操作需要接受三個參數：

1. 內存位置

2. 舊的預期值

3. 新值
   

這個操作的做法就是看指定內存位置的值符不符合舊的預期值，如果符合的話就將它替換成新值。它對應的是處理器提供的一個原子性指令 - CMPXCHG。

比如AtomicLong的自增操作：

public final long incrementAndGet() {
 for (;;) {
  long current = get(); // Step 1
  long next = current + 1; // Step 2
  if (compareAndSet(current, next)) // Step 3
   return next;
 }
}

public final boolean compareAndSet(long expect, long update) {
 return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}

我們考慮兩個線程T1和T2，同時執(zhí)行到了上述Step 1處，都拿到了current值為1。然后通過Step 2之后，current在兩個線程中都被設置為2。

緊接著，來到Step 3。假設線程T1先執(zhí)行，此時符合CompareAndSet的設置規(guī)則，因此內存位置對應的值被設置成2，線程T1設置成功。當線程T2執(zhí)行的時候，由于它預期current為1，但是實際上已經變成了2，所以CompareAndSet執(zhí)行不成功，進入到下一輪的for循環(huán)中，此時拿到最新的current值為2，如果沒有其它線程感染的話，再次執(zhí)行CompareAndSet的時候就能夠通過，current值被更新為3。

所以不難發(fā)現，CAS的工作主要依賴于兩點：

1. 無限循環(huán)，需要消耗部分CPU性能

2. CPU原子指令CompareAndSet
   

雖然它需要耗費一定的CPU Cycle，但是相比鎖而言還是有其優(yōu)勢，比如它能夠避免線程阻塞引起的上下文切換和調度。這兩類操作的量級明顯是不一樣的，CAS更輕量一些。

關于Java中volatile++不是原子性的原因是什么就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。