并發編程之：Atomic

大家好，我是小黑，一個在互聯網茍且偷生的農民工。

在開始講今天的內容之前，先問一個問題，使用int類型做加減操作是不是線程安全的呢？比如 i++ ,++i，i=i+1這樣的操作在并發情況下是否會有問題？

我們通過運行代碼來看一下。

public class AtomicDemo {public static void main(String[] args) throws InterruptedException {Data data = new Data();Thread a = new Thread(() -> {for (int i = 0; i < 100000; i++) {System.out.println(Thread.currentThread().getName()+"_"+data.increment());}}, "A");Thread b = new Thread(() -> {for (int i = 0; i < 100000; i++) {System.out.println(Thread.currentThread().getName()+"_"+data.increment());}}, "B");a.start();b.start();// 等待A，B線程執行完畢a.join();b.join();System.out.println(data.getI());} }class Data {private volatile int i = 0;public int increment() {i++;return i;}public int getI() {return i;} }

以上代碼比較簡單，通過A,B兩個線程同時對Data對象中的i執行++操作，各自執行100000次，最后輸出，如果說i++操作時線程安全的，那么最后輸出的結果應該是200000，但是我們運行代碼會看到如下結果：

我們發現最后輸出的并不是200000，而是199982，如果多執行幾次的話，這個結果會發生變化，并且大多數情況下不會是200000。這主要是因為int類型的++操作不是原子的，i++同等于i=i+1,也就是加1這一步和對i重新賦值這一步不是同時完成的，不具備原子性，所以我們得出結論int類型的操作不是線程安全的。

在很多實際場景中都需要對一個數據進行并發操作，比如電商的秒殺活動中，對一個商品數量的扣減，那么我們想保證安全性應該怎么做呢？

首先我們可以想到的就是使用synchronized關鍵字對increment()這個方法加鎖，這樣就能保證每次只有一個線程能訪問。

但是之前的文章中我們有講到synchronized是一個重量級的悲觀鎖，我們的業務場景的并發可能是一段時間內的，多數情況下可能并不會有很多競爭，所以有沒有更好的處理方式呢，答案就是通過AtomicInteger。

AtomicInteger

AtomicInteger是java.util.concurrent.atomic包中的一個類。我們看官方文檔對于這個包的描述，說它是支持單個變量上的無鎖線程安全編程的工具包，好像和我們期望的一樣，在不加鎖的情況下達到線程安全。

我們來修改一下上面例子的代碼。

class Data {private volatile AtomicInteger i = new AtomicInteger(0);public int increment() {return i.incrementAndGet();}public int getI() {return i.get();} }

很簡單，將原來的int修改為AtomicInteger，在執行increment()方法進行增加操作時，調用incrementAndGet()方法就可以了。同樣我們運行代碼，會發現，不管運行多少次，代碼最后執行的結果都是一樣的，200000。所以我們說AtomicInteger是線程安全的。除了incrementAndGet()方法以外，還有很多其他的操作，比如decrementAndGet()，getAndIncrement()，getAndDecrement()，getAndAdd(int delta)，addAndGet(int delta)等等，實際上就是對i++，++i，i=i+n，i+=n這些操作的原子實現。

除了AtomicInteger以外，java.util.concurrent.atomic包中還有一些其他類型，比如AtomicBoolean，AtomicLong等。

實現原理

那么AtomicInteger是如何實現在不使用synchronized的情況下保證原子性的呢？我們來看一下源碼。

public class AtomicInteger extends Number implements java.io.Serializable {private static final Unsafe unsafe = Unsafe.getUnsafe();// value在內存中的地址偏移值private static final long valueOffset;static {try {valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) { throw new Error(ex); }}// value為volatile的保證內存可見性private volatile int value;public final int incrementAndGet() {return unsafe.getAndAddInt(this, valueOffset, 1) + 1;}} public final class Unsafe {public final int getAndAddInt(Object var1, long var2, int var4) {int var5;do {// 獲取volatile的Int，保證拿到的值是最新的var5 = this.getIntVolatile(var1, var2);// compareAndSwapInt 比較并交換 native方法} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;} }

通過源碼我們看到在incrementAndGet()方法中調用了Unsafe類的getAndAddInt方法，在這個方法內部對value進行compareAndSwapInt操作。通過這個方法名我們就可以看出是比較并交換，也就是我們之前提到過的CAS。也就是在執行賦值操作時，先看一下當前值是不是我加之前的值，如果不是，那我就重新加一次之后再進行比較，是一個循環的過程，這個過程也稱作自旋。

CAS這種處理方式雖然很高效的解決了原子操作，但是它仍然存在三個問題，在實際開發中一定要注意，結合自己的實際業務場景使用。

ABA問題

什么是ABA問題呢，通俗理解，就是你大爺還是你大爺，你大媽已經不是你大媽了~

什么意思呢？就是當線程1取到A之后，有另一個線程2把A變成了B，又變成了A，當線程1再修改完值進行CAS比較時，發現值還是A，和自己取到的一樣，就直接更新了，但是在這個過程中，這個A中間是發生過變化的。就好比一個小偷，偷了別人家錢然后再還回來，還是原來的錢嗎？雖然你的錢沒變，但是這個小偷已經觸犯了法律，而你自己還不知道。

為了解決這個問題，atomic包中提供了一個類，我們看下是如何解決的。

public static void main(String[] args) throws InterruptedException {AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);new Thread(() -> {try {int stamp = ref.getStamp();String reference = ref.getReference();System.out.println("線程1拿到的值:" + reference + " stamp:" + stamp);// sleep 2秒模擬線程切換到2TimeUnit.SECONDS.sleep(2);boolean success = ref.compareAndSet(reference, "C", stamp, stamp + 1);System.out.println(Thread.currentThread().getName() + " " + success);} catch (InterruptedException e) {e.printStackTrace();}}, "線程1").start();new Thread(() -> {// 先改為Bint stamp = ref.getStamp();String reference = ref.getReference();System.out.println("線程2拿到的值:" + reference + " stamp:" + stamp);ref.compareAndSet(reference, "B", stamp, stamp + 1);// 再改回Astamp = ref.getStamp();reference = ref.getReference();System.out.println("線程2拿到的值:" + reference + " stamp:" + stamp);ref.compareAndSet(reference, "A", ref.getStamp(), stamp + 1);}, "線程2").start(); }

我們可以看到AtomicStampedReference的compareAndSet()方法有4個參數：

expectedReference：表示期望的引用值

newReference：表示要修改后的新引用值

expectedStamp：表示期望的戳（版本號）

newStamp：表示修改后新的戳（版本號）

什么意思呢？就是在修改時不光比較值是不是和獲取到的一樣，還要比較版本號。這樣的話，每次操作時都對版本號加1，那么就算值從A改為B再改回A，但是版本號從0改成了1又改成了2，并沒有變回0，就可以避免ABA問題的發生。

循環時間變長

在并發非常大的情況下，使用CAS可能會存在一些線程一直循環修改不成功，導致循環時間變長，會給CPU帶來很大的執行開銷。并且由于AtomicReference中的引用是volatile的，為了保證內存可見性，需要保證緩存一致性，通過總線傳輸數據，當有大量的CAS循環時，會產生總線風暴。

只能保證一個變量的原子操作

CAS的第三個問題就是AtomicReference中只能存放一個變量，如果需要保證多個變量操作的原子性，是做不到的。對于這種情況只能使用synchronized或者juc包中的Lock工具。

小結

簡單做個小結，使用int類型在并發場景下存在線程安全問題，可以用AtomicInteger來保證原子性操作，Atomic是通過CAS做到無鎖線程安全的。但是CAS有三個問題，第一ABA問題，可以通過AtomicStampedReference解決；第二競爭激烈情況下循環時間會變長，會產生總線風暴；第三只能保證一個變量的原子操作。

具體業務場景中是使用synchronized，Lock等鎖工具還是使用Atomic的CAS無鎖操作，還是要結合場景考慮。

---

好的，今天的內容就到這里，我們下期見。

關注公眾號【小黑說Java】干貨不斷~

總結

以上是生活随笔為你收集整理的并发编程之：Atomic的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。