并發編程之：Atomic-有解無憂

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

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

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

public class AtomicDemo {
    public static void main(String[] args) throws InterruptedException {
        Data data = https://www.cnblogs.com/heiz123/p/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秒模擬執行緒切換到2
            TimeUnit.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(() -> {
        // 先改為B
        int stamp = ref.getStamp();
        String reference = ref.getReference();
        System.out.println("執行緒2拿到的值:" + reference + " stamp:" + stamp);
        ref.compareAndSet(reference, "B", stamp, stamp + 1);
        // 再改回A
        stamp = 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無鎖操作，還是要結合場景考慮，

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

并發編程之：Atomic
并發編程之：執行緒
關注我的微信公眾號【小黑說Java】,更多干貨內容，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/296715.html

標籤：Java

上一篇：java修飾符

下一篇：劍指offer 計劃1（堆疊與佇列）---java