一個小例子說說什麼是執(zhí)行緒安全性

線程安全，下面我們先來看一段程式碼，看看運行後會發(fā)生什麼：

public class Test {
    private static int inc = 0;

    public static void main(String[] args) {
     // 設置柵欄，保證主線程能獲取到程序各個線程全部執(zhí)行完之后的值
        CountDownLatch countDownLatch = new CountDownLatch(1000000);
        // 設置100個線程同時執(zhí)行
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
             // 循環(huán)10000次，對inc實現(xiàn) +1 操作
                for (int j = 0; j < 10000; j++) {
                    inc++;
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 運行完畢，期望獲取的結果是 1000000
        System.out.println("執(zhí)行完畢，inc的值為：" + inc);
    }
}

程式中，我創(chuàng)建了100個線程，每個線程中對共享變數(shù)inc進行累加10000次的操作，如果是同步執(zhí)行的話，inc最終的值應該是1000000，但我們知道在多執(zhí)行緒中，程式是並發(fā)執(zhí)行的，也就是說不同的執(zhí)行緒可能會同時讀取到主記憶體相同的值，例如這樣的場景：

• 執(zhí)行緒A在某一個瞬間讀取了主記憶體的inc值為1000，它在自己的工作記憶體1，inc變成了1001；
• 線程B在同樣的瞬間讀取到了主記憶體的inc值為1000，它也在自己的工作記憶體中對inc的值1， inc變成了1001；
• 他們要往主記憶體寫入inc的值的時候並沒有做任何的同步控制，所以他們都有可能把自己工作內存的1001寫入到主內存；
• 那麼很顯然主內存在進行兩次1 操作後，實際的結果只進行了一次1，變成了1001。

這就是一個很典型的多執(zhí)行緒並發(fā)修改共享變數(shù)所帶來的問題，那麼很顯然，它的運行結果也如我們分析的那樣，某些情況下達不到1000000：

執(zhí)行完畢，inc的值為：962370

有些人說透過volatile關鍵字可以解決這個問題，因為volatile可以保證執(zhí)行緒之間的可見性，也就是說執(zhí)行緒可以讀取到主記憶體最新的變數(shù)值，然後對其進行操作。

注意了，volatile只能保證線程的可見性，而不能保證線程操作的原子性，雖然線程讀取到了主記憶體的inc的最新值，但是讀取、inc 1、寫入主記憶體 是三步驟操作，所以volatile無法解決共享變數(shù)執(zhí)行緒安全的問題。

那麼要如何解決這個問題？ Java為我們提供下面幾種解決方案。

幾種保證線程安全的方案

1. 通過synchronized關鍵字實現(xiàn)同步：

public class Test {
    private static int inc = 0;

    public static void main(String[] args) {
        // 設置柵欄，保證主線程能獲取到程序各個線程全部執(zhí)行完之后的值
        CountDownLatch countDownLatch = new CountDownLatch(1000000);
        // 設置100個線程同時執(zhí)行
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 循環(huán)10000次，對inc實現(xiàn) +1 操作
                for (int j = 0; j < 10000; j++) {
                 // 設置同步機制，讓inc按照順序執(zhí)行
                    synchronized (Test.class) {
                        inc++;
                    }

                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執(zhí)行完畢，inc的值為：" + inc);
    }
}

在上面的代碼中，我們給 inc ++ 外面加了一層代碼，使用 synchronized 設置類鎖，保證了代碼的同步執(zhí)行，這是一種基于JVM自身的機制來保障線程的安全性，如果在并發(fā)量比較大的情況下，synchronized 會升級為重量級的鎖，效率很低。synchronized無法獲取當前線程的鎖狀態(tài)，發(fā)生異常的情況下會自動解鎖，但是如果線程發(fā)生阻塞，它是不會釋放鎖的

執(zhí)行結果：

執(zhí)行完畢，inc的值為：1000000

可以看到，這種方式是可以保證線程安全的。

2. 通過Lock鎖實現(xiàn)同步

public class Test {
    private static int inc = 0;
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 設置柵欄，保證主線程能獲取到程序各個線程全部執(zhí)行完之后的值
        CountDownLatch countDownLatch = new CountDownLatch(1000000);

        // 設置100個線程同時執(zhí)行
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 循環(huán)10000次，對inc實現(xiàn) +1 操作
                for (int j = 0; j < 10000; j++) {
                 // 設置鎖
                    lock.lock();
                    try {
                        inc++;
                    } finally {
                     // 解鎖
                        lock.unlock();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執(zhí)行完畢，inc的值為：" + inc);
    }
}

ReentrantLock的底層是通過AQS + CAS來實現(xiàn)的，在并發(fā)量比較小的情況下，它的性能不如 synchronized，但是隨著并發(fā)量的增大，它的性能會越來越好，達到一定量級會完全碾壓synchronized。并且Lock是可以嘗試獲取鎖的，它通過代碼手動去控制解鎖，這點需要格外注意。

執(zhí)行結果：

執(zhí)行完畢，inc的值為：1000000

3. 使用 Atomic 原子類

public class Test {
    private static AtomicInteger inc = new AtomicInteger();

    public static void main(String[] args) {
        // 設置柵欄，保證主線程能獲取到程序各個線程全部執(zhí)行完之后的值
        CountDownLatch countDownLatch = new CountDownLatch(1000000);

        // 設置100個線程同時執(zhí)行
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 循環(huán)10000次，對inc實現(xiàn) +1 操作
                for (int j = 0; j < 10000; j++) {
                    inc.getAndAdd(1);
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執(zhí)行完畢，inc的值為：" + inc.get());
    }
}

AtomicInteger 底層是基于 CAS 的樂觀鎖實現(xiàn)的，CAS是一種無鎖技術，相對于前面的方案，它的效率更高一些，在下面會詳細介紹。

執(zhí)行結果：

執(zhí)行完畢，inc的值為：1000000

4. 使用 LongAdder 原子類

public class Test {
    private static LongAdder inc = new LongAdder();

    public static void main(String[] args) {
        // 設置柵欄，保證主線程能獲取到程序各個線程全部執(zhí)行完之后的值
        CountDownLatch countDownLatch = new CountDownLatch(1000000);

        // 設置100個線程同時執(zhí)行
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 循環(huán)10000次，對inc實現(xiàn) +1 操作
                for (int j = 0; j < 10000; j++) {
                    inc.increment();
                    countDownLatch.countDown();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執(zhí)行完畢，inc的值為：" + inc.intValue());
    }
}

LongAdder 原子類在 JDK1.8 中新增的類，其底層也是基于 CAS 機制實現(xiàn)的。適合于高并發(fā)場景下，特別是寫大于讀的場景，相較于 AtomicInteger、AtomicLong 性能更好，代價是消耗更多的空間，以空間換時間。

執(zhí)行結果：

執(zhí)行完畢，inc的值為：1000000

CAS理論

講到現(xiàn)在，終于我們今天的主角要登場了，她就是CAS。

CAS的意思是比較與交換（Compare And Swap），它是樂觀鎖的一種實現(xiàn)機制。

什么是樂觀鎖？通俗的來說就是它比較樂觀，每次在修改變量的值之前不認為別的線程會修改變量，每次都會嘗試去獲得鎖，如果獲取失敗了，它也會一直等待，直到獲取鎖為止。說白了，它就是打不死的小強。

而悲觀鎖呢，顧名思義，就比較悲觀了，每次在修改變量前都會認為別人會動這個變量，所以它會把變量鎖起來，獨占，直到自己修改完畢才會釋放鎖。說白了，就是比較自私，把好東西藏起來自己偷偷享用，完事了再拿出來給別人。像之前的synchronized關鍵字就是悲觀鎖的一種實現(xiàn)。

CAS是一種無鎖原子算法，它的操作包括三個操作數(shù)：需要讀寫的內存位置(V)、預期原值(A)、新值(B)。僅當 V值等于A值時，才會將V的值設為B，如果V值和A值不同，則說明已經有其他線程做了更新，則當前線程繼續(xù)循環(huán)等待。最后，CAS 返回當前V的真實值。CAS 操作時抱著樂觀的態(tài)度進行的，它總是認為自己可以成功完成操作。

CAS的實現(xiàn)

在Java中，JUC的atomic包下提供了大量基于CAS實現(xiàn)的原子類：

我們以AtomicInteger來舉例說明。

AtomicInteger類內部通過一個Unsafe類型的靜態(tài)不可變的變量unsafe來引用Unsafe的實例。

 // setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();

然后，AtomicInteger類用value保存自身的數(shù)值，并用get()方法對外提供。注意，它的value是使用volatile修飾的，保證了線程的可見性。

private volatile int value;

/**
 * Creates a new AtomicInteger with the given initial value.
 *
 * @param initialValue the initial value
 */
public AtomicInteger(int initialValue) {
    value = initialValue;
}

/**
 * Gets the current value.
 *
 * @return the current value
 */
public final int get() {
    return value;
}

一路跟蹤incrementAndGet方法到的末尾可以看到是一個native的方法：

/**
 * Atomically increments by one the current value.
 *
 * @return the updated value
 */
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

//  getAndAddInt 方法
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

// compareAndSet方法
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

可以看到其實incrementAndGet內部的原理就是通過compareAndSwapInt調用底層的機器指令不斷比較內存舊值和期望的值，如果比較返回false就繼續(xù)循環(huán)比較，如果返回true則將當前的新值賦給內存里的值，本次處理完畢。

由此我們知道，原子類實現(xiàn)的自增操作可以保證原子性的根本原因在于硬件（處理器）的相關指令支持。將語義上需要多步操作的行為通過一條指令來完成，CAS指令可以達到這個目的。

CAS的缺點

• 作為樂觀鎖定的一種實現(xiàn)，當多執(zhí)行緒競爭資源激烈的情況下，多個執(zhí)行緒會發(fā)生自旋等待，會消耗一定的CPU資源。
• CAS不可避免會出現(xiàn)ABA的問題，關於ABA問題的詮釋和解決方案，可以參考我的這篇文章：面試官問你：你知道什麼是ABA問題嗎？
  
  

好了，本期關於CAS的分享就到這裡結束了。 並發(fā)作為Java程式設計的基石，是一個非常重要的知識點，如果同學們對這塊的掌握比較薄弱，希望在讀完文章後能自己動手敲敲程式碼，思考一下什麼是CAS，有哪些優(yōu)缺點，實作方式有哪些。 當然，並發(fā)是一個非常大的概念，這裡只是拋磚引玉，提到了其中的一個小知識點，給出了我自己學習的一點心得體會。 如果有闡述不到位或錯誤的地方，請私訊我一起討論，感謝！

我是程式設計師青戈，本期的面試問題分享到這裡就結束了，想提升自己，進階大工廠的同學一定要關注我的公眾號：Java學習指南，這裡每天會從實際的面試出發(fā)帶你學習和總結Java相關的知識，幫助你擴充技術棧，提昇個人實力。我們下期見~