[[399624]]

本文轉載自微信公眾號「牧小農」，作者牧小農。轉載本文請聯系牧小農公眾號。

一、定義：什么是線程安全性

當多個線程訪問某個類時，不管運行時環境采用 何種調度方式 或者這些進程將如何交替執行，并且在主調代碼中不需要任何額外的同步或協同，這個類都能表現出正確的行為，那么就稱這個類就是線程安全的。

二、線程安全性的三個體現

原子性：提供互斥訪問，同一時刻只能有一個線程對數據進行操作(Atomic、CAS算法、synchronized、Lock)

可見性：一個主內存的線程如果進行了修改，可以及時被其他線程觀察到(synchronized、volatile)

有序性：如果兩個線程不能從 happens-before原則 觀察出來，那么就不能觀察他們的有序性，虛擬機可以隨意的對他們進行重排序，導致其觀察觀察結果雜亂無序(happens-before原則)

三、線程安全性：原子性

3.1、原子性 — Atomic包

在Java jdk中里面提供了很多Atomic類

• AtomicXXX：CAS、Unsafe.compareAndSwapInt
• AtomicLong、LongAdder
• AtomicReference、AtomicReferenceFieldUpdater
• AtomicStampReference：CAS的ABA問題

由于CAS原語的直接操作與計算機底層的聯系很大，CAS原語有三個參數， 內存地址、 期望值、 新值。我們在Java中一般不去直接寫CAS相關的代碼，JDK為我們封裝在AtomicXXX中，因此，我們直接使用就可以了。

我們在 java.util.concurrent.atomic目錄中可以看到我們這些類，包下提供了 AtomicBoolean、 AtomicLong、 AtomicInteger三種原子更新基本類型和一個比較好玩的類 AtomicReference，這些類都有一個共同點，都支持CAS，以 AtomicInteger為重點講解。

3.1.1、AtomicInteger

AtomicInteger是一個提供原子操作的Integer類，通過線程安全的方式操作加減

以下是 AtomicIntege基本包括的方法：

public final int getAndSet(int newValue)       //給AtomicInteger設置newValue并返回加oldValue 
public final boolean compareAndSet(int expect, int update)    //如果輸入的值和期望值相等就set并返回true/false 
public final int getAndIncrement()     //對AtomicInteger原子的加1并返回當前自增前的value 
public final int getAndDecrement()   //對AtomicInteger原子的減1并返回自減之前的的value 
public final int getAndAdd(int delta)   //對AtomicInteger原子的加上delta值并返加之前的value 
public final int incrementAndGet()   //對AtomicInteger原子的加1并返回加1后的值 
public final int decrementAndGet()    //對AtomicInteger原子的減1并返回減1后的值 
public final int addAndGet(int delta)   //給AtomicInteger原子的加上指定的delta值并返回加后的值 

示例：

import lombok.extern.slf4j.Slf4j; 
 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
import java.util.concurrent.atomic.AtomicInteger; 
 
@Slf4j 
public class AtomicIntegerExample { 
 
    // 請求總數 
    public static int clientTotal = 5000; 
 
    // 同時并發執行的線程數 
    public static int threadTotal = 200; 
 
    public static AtomicInteger count = new AtomicInteger(0); 
 
    public static void main(String[] args) throws Exception { 
      //獲取線程池 
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        //定義信號量 
        final Semaphore semaphore = new Semaphore(threadTotal); 
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
        for (int i = 0; i < clientTotal ; i++) { 
            executorService.execute(() -> { 
                try { 
                    semaphore.acquire(); 
                    add(); 
                    semaphore.release(); 
                } catch (Exception e) { 
                    log.error("exception", e); 
                } 
                countDownLatch.countDown(); 
            }); 
        } 
        countDownLatch.await(); 
        executorService.shutdown(); 
        log.info("count:{}", count.get()); 
    } 
 
    private static void add() { 
        count.incrementAndGet(); 
    } 
} 

這里我們使用請求總數為：5000，同時執行的并發線程數為：200，我們最終需要得到結果為：5000，這個執行結果才算正確。

查看返回結果：

13:43:26.473 [main] INFO com.mmall.concurrency.example.atomic.AtomicIntegerExample - count:5000 

最后結果是 5000表示是線程安全的。

我們來看看 AtomicInteger底層代碼中到底為我們做了什么?首先我們來看 AtomicInteger.incrementAndGet() 方法

public class AtomicInteger extends Number implements java.io.Serializable{ 
/** 
     *  對AtomicInteger原子的加1并返回加1后的值 
     * @return 更新的值 
     */ 
    public final int incrementAndGet() { 
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1; 
    } 
} 

AtomicInteger 調用了java底層的unsafe.getAndAddInt()```方法，這里是實現CAS 的關鍵。

incrementAndGet()是將自增后的值返回，還有一個方法 getAndIncrement()是將自增前的值返回，分別對應 ++i和 i++操作。同樣的 decrementAndGet()和 getAndDecrement()則對 --i和i--操作。

Unsafe類是在sun.misc包下，不屬于Java標準。但是很多Java的基礎類庫，包括一些被廣泛使用的高性能開發庫都是基于 
Unsafe類開發的，比如Netty、Cassandra、Hadoop、Kafka等。Unsafe類在提升Java運行效率，增強Java語言底層操作 
能力方面起了很大的作用。Unsafe類使Java擁有了像C語言的指針一樣操作內存空間的能力，同時也帶來了指針的問題。 
過度的使用Unsafe類會使得出錯的幾率變大，因此Java官方并不建議使用的，官方文檔也幾乎沒有。通常我們最好也不 
要使用Unsafe類，除非有明確的目的，并且也要對它有深入的了解才行。 

再來看 Unsafe.getAndAddInt()方法

/* 
   * 其中getIntVolatile和compareAndSwapInt都是native方法 
   * getIntVolatile是獲取當前的期望值 
   * compareAndSwapInt就是我們平時說的CAS(compare and swap)，通過比較如果內存區的值沒有改變，那么就用新值直接給該內存區賦值 
   */ 
    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; 
    } 
     
    public native int getIntVolatile(Object var1, long var2); 
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); 

我們可以看到 getAndAddInt(Objectvar1,longvar2,intvar4)，傳進來的第一個參數是當前的一個對象,也就是我們的：count.incrementAndGet()，在 getAndAddInt()中，var1就是count，var2就是當前的值，比如當前循環中count值為 2，var4為每次遞增1

其次 getAndAddInt()方法中涉及到的兩個方法調用都定義為native，即java底層實現的本地方法

• getIntVolatile()：獲取保存當前對象count的主存地址的引用(注意不是對象的值，是引用)。
• compareAndSwapInt()：比較當前對象的值和底層該對象的值是否相等，如果相等，則將當前對象值加1，如果不相等，則重新去獲取底層該對象的值，這個方法的實現就是CPU的CAS(compare and swap)操作。

我們知道 volatile具有一致性的特征，但是它不具備原子性，為什么 AtomicInteger卻同時具備一致性和原子性，原來在 AtomicInteger源碼中實現了這樣一串代碼：privatevolatileintvalue;，在 AtomicInteger內部實現就使用了 volatile關鍵字，這就是為什么執行CAS(對CAS有疑問的點擊此處)操作的時候，從底層獲取的數據就是最新的數據：

如果當前要保存的值和內存中最新的值不相等的話，說明在這個過程中被其他線程修改了，只

能獲取更新當前值為最新值，再那這個當前值再去和重新去內存獲取的最新值比較，直到二者

相等的時候，才完成+1的過程.

使用 AtomicInteger的好處在于，它不同于 sychronized關鍵字或 lock用鎖的形式來實現原子性，加鎖會影響性能，而是采用循環比較的形式來提高性能。

3.1.2、AtomicLong

AtomicLong 是作用是對長整形進行原子操作，依靠底層的cas來保障原子性的更新數據，在要添加或者減少的時候，會使用死循環不斷地cas到特定的值，從而達到更新數據的目的。

import lombok.extern.slf4j.Slf4j; 
 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
import java.util.concurrent.atomic.AtomicLong; 
 
@Slf4j 
public class AtomicLongExample { 
 
    // 請求總數 
    public static int clientTotal = 5000; 
 
    // 同時并發執行的線程數 
    public static int threadTotal = 200; 
 
    public static AtomicLong count = new AtomicLong(0); 
 
    public static void main(String[] args) throws Exception { 
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        final Semaphore semaphore = new Semaphore(threadTotal); 
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
        for (int i = 0; i < clientTotal ; i++) { 
            executorService.execute(() -> { 
                try { 
                    semaphore.acquire(); 
                    add(); 
                    semaphore.release(); 
                } catch (Exception e) { 
                    log.error("exception", e); 
                } 
                countDownLatch.countDown(); 
            }); 
        } 
        countDownLatch.await(); 
        executorService.shutdown(); 
        log.info("count:{}", count.get()); 
    } 
 
    private static void add() { 
        count.incrementAndGet(); 
        // count.getAndIncrement(); 
    } 
} 

執行結果：

14:59:38.978 [main] INFO com.mmall.concurrency.example.atomic.AtomicLongExample - count:5000 

最后結果是 5000表示是線程安全的。

3.1.3、AtomicBoolean

AtomicBoolean位于java.util.concurrent.atomic包下，是java提供給的可以保證數據的原子性操作的一個類

import lombok.extern.slf4j.Slf4j; 
 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
import java.util.concurrent.atomic.AtomicBoolean; 
 
@Slf4j 
public class AtomicBooleanExample { 
 
    private static AtomicBoolean isHappened = new AtomicBoolean(false); 
 
    // 請求總數 
    public static int clientTotal = 5000; 
 
    // 同時并發執行的線程數 
    public static int threadTotal = 200; 
 
    public static void main(String[] args) throws Exception { 
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        final Semaphore semaphore = new Semaphore(threadTotal); 
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
        for (int i = 0; i < clientTotal ; i++) { 
            executorService.execute(() -> { 
                try { 
                    semaphore.acquire(); 
                    test(); 
                    semaphore.release(); 
                } catch (Exception e) { 
                    log.error("exception", e); 
                } 
                countDownLatch.countDown(); 
            }); 
        } 
        countDownLatch.await(); 
        executorService.shutdown(); 
        log.info("isHappened:{}", isHappened.get()); 
    } 
 
    private static void test() { 
        if (isHappened.compareAndSet(false, true)) { 
            log.info("execute"); 
        } 
    } 
} 

返回結果：

15:04:54.954 [pool-1-thread-2] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - execute 
15:04:54.971 [main] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - isHappened:true 

這里我們發現 log.info("execute");，在代碼中只執行了一次，并且 isHappened:true的值為true,這是為啥呢?

這里是因為當程序第一次 compareAndSet()的時候，使得 isHappend變為了true，因為原子性的關系，沒有其他線程進行干擾，通過使用AtomicBoolean，我們使某段代碼只執行一次。

3.1.4、AtomicReference

AtomicReference和 AtomicInteger非常類似，不同之處就在于 AtomicInteger是對整數的封裝，底層采用的是 compareAndSwapInt實現CAS，比較的是數值是否相等，而 AtomicReference則對應普通的對象引用，底層使用的是 compareAndSwapObject實現CAS，比較的是兩個對象的地址是否相等。也就是它可以保證你在修改對象引用時的線程安全性。

多個線程之間的操作無論采用何種執行時序或交替方式，都要保證不變性條件不被破壞，要保持狀態的一致性，就需要在單個原子操作中更新相關的狀態變量。

import lombok.extern.slf4j.Slf4j; 
 
import java.util.concurrent.atomic.AtomicReference; 
 
@Slf4j 
public class AtomicReferenceExample { 
 
    private static AtomicReference<Integer> count = new AtomicReference<>(0); 
 
    public static void main(String[] args) { 
        count.compareAndSet(0, 2);  
        count.compareAndSet(0, 1); 
        count.compareAndSet(1, 3);  
        count.compareAndSet(2, 4);  
        count.compareAndSet(3, 5);  
        log.info("count:{}", count.get()); 
    } 
} 

大家覺得我們輸出的結果會是多少?

返回結果：

15:26:59.680 [main] INFO com.mmall.concurrency.example.atomic.AtomicReferenceExample - count:4 

為什么是4呢?首先我們 要說的是 publicfinalbooleancompareAndSet(V expect,V update)這個方法，這個方法主要的作用是通過比對兩個對象，然后更新為新的對象，這里的比對兩個對象，比對的方式不是 equals而是 ==,意味著比對的是內存的中地址。

1、首先我們創建 count的初始化為0 2、在main方法中 count.compareAndSet(0,2);，判斷count為0時賦值為2 3、在 count.compareAndSet(0,1);和 count.compareAndSet(1,3);判斷count是否為1或者0，因為上一步我們已經賦值為2了，所以判斷不成立 4、在 count.compareAndSet(2,4);判斷count是否為2，等式成立 5、最好輸出結果為4

count.compareAndSet(0, 2); //count=0?賦值 2，判斷成立，此時count=0，更新后為2 
count.compareAndSet(0, 1); //count=0?賦值 1，判斷不成立，此時count=2 
count.compareAndSet(1, 3); //count=1?賦值 3，判斷不成立，此時count=2 
count.compareAndSet(2, 4); //count=2?賦值 4，判斷成立，此時count=2，更新后count=4 
count.compareAndSet(3, 5); //count=3?賦值 5，判斷不成立，此時count=4 

所以我們輸出結果為：4

3.1.5、CAS中ABA問題的解決

CAS并非完美的，它會導致ABA問題，例如：當前內存的值一開始是A，被另外一個線程先改為B然后再改為A，那么當前線程訪問的時候發現是A，則認為它沒有被其他線程訪問過。在某些場景下這樣是存在錯誤風險的。比如在鏈表中。如何解決這個ABA問題呢，大多數情況下樂觀鎖的實現都會通過引入一個版本號標記這個對象，每次修改版本號都會變話，比如使用時間戳作為版本號，這樣就可以很好的解決ABA問題。在JDK中提供了 AtomicStampedReference類來解決這個問題，這個類維護了一個int類型的標記stamp，每次更新數據的時候順帶更新一下stamp。

3.2、原子性 — synchronized

synchronized是一種同步鎖，通過鎖實現原子操作。1、修飾代碼塊：大括號括起來的代碼，作用于調用的對象 2、修飾方法：整個方法，作用于調用的對象 3、修飾靜態方法：整個靜態方法，作用于所有對象 4、修飾類：括號括起來的部分，作用于所有對象

詳細可以查看，我寫的關于：synchronized的博客，因為寫過所以就不做過多描述。

3.3、原子性 — 對比

Atomic：競爭激烈時能維持常態，比Lock性能好， 只能同步一個值

synchronized：不可中斷鎖，適合競爭不激烈，可讀性好的情況

Lock：可中斷鎖，多樣化同步，競爭激烈時能維持常態

四、線程安全性：可見性

簡介：一個線程對主內存的修改可以及時被其他線程觀察到

導致共享變量在線程間不可見的原因：1.線程交叉執行 2.重新排序結合線程交叉執行 3.共享變量更新后的值沒有在工作內存中與主內存間及時更新

4.1 可見性 — syncronized

JMM關于 syncronized的兩條規定：

線程解鎖前，必須把共享變量的最新值刷新到主內存中

線程加鎖時，將清空工作內存中共享變量的值，從而使得使用共享變量時需要從主內存中重新讀取最新的值(注意：加鎖與解鎖是同一把鎖) 由于syncronized可以保證原子性及可見性，變量只要被syncronized修飾，就可以放心的使用

4.2 可見性 — volatile

通過加入 內存屏障和 禁止重排序優化來實現可見性。具體實現過程：

• 對 volatile變量寫操作時，會在寫操作后加入一條 store屏障指令，將本地內存中的共享變量值刷新到主內存
• 對 volatile變量讀操作時，會在讀操作前加入一條 load屏障指令，從主內存中讀取共享變量
• volatile 不能保證操作的原子性，也就是不能保證線程安全性， 如果需要使用 volatile 必須滿足以下兩個條件：
• 對變量的寫操作不依賴與變量當前的值。
• 該變量沒有包含在具有其他變量的不變的式子中。

所以 volatile修飾的變量適合作為狀態標記量。

注：以下圖片為資料中獲取，如有雷同，純屬巧合

示例：

import lombok.extern.slf4j.Slf4j; 
 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
 
@Slf4j 
public class VolatileExample { 
 
    // 請求總數 
    public static int clientTotal = 5000; 
 
    // 同時并發執行的線程數 
    public static int threadTotal = 200; 
 
    public static volatile int count = 0; 
 
    public static void main(String[] args) throws Exception { 
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        final Semaphore semaphore = new Semaphore(threadTotal); 
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
        for (int i = 0; i < clientTotal ; i++) { 
            executorService.execute(() -> { 
                try { 
                    semaphore.acquire(); 
                    add(); 
                    semaphore.release(); 
                } catch (Exception e) { 
                    log.error("exception", e); 
                } 
                countDownLatch.countDown(); 
            }); 
        } 
        countDownLatch.await(); 
        executorService.shutdown(); 
        log.info("count:{}", count); 
    } 
 
    private static void add() { 
        count++; 
    } 
} 

返回結果：

16:12:01.404 [main] INFO com.mmall.concurrency.example.count.VolatileExample4 - count:4986 

通過執行代碼我們可以發現，返回結果并不是我們想看到的5000，說明這個是線程不安全的類

主要是因為當我們執行 conut++時分成了三步：1、取出當前內存count值，這時count值時最新的 2、+1操作 3、重新寫回主存

例如：有兩個線程同時在執行 count++，兩個內存都執行了第一步，比如當前count值為99，它們都讀到了這個count值，然后兩個線程分別執行了 +1，并寫回主存，這樣就丟掉了一次 +1的操作。

五、線程安全性：有序性

在JMM中，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到單線程程序的執行，卻會影響到多線程并發執行的正確性。

通過volatile、synchronized、lock保證有序性

5.1 happens-before原則

• 程序次序規則：一個線程內，按照代碼順序，書寫在前面的操作先行發生于書寫在后面的操作
• 鎖定規則：一個 unLock操作先行發生于后面對同一個鎖的 Lock()操作，也就是說只有先解鎖才能對下面的線程進行加鎖
• volatile變量規則：對一個變量的寫操作先行發生于后面對這個變量的讀操作
• 傳遞規則：如果操作A先行發生與操作B,而操作B先行發生于操作C，則操作A先行發生于操作C
• 線程啟動規則： Thread對象的 start()方法先行發生于此線程的每一個動作，一個線程只有執行了 start()方法后才能做其他的操作
• 線程終端規則：對線程 interrupt()方法的調用先行發生與被中斷線程的代碼檢測到中斷事件的發生(只有執行了 interrupt()方法才可以檢測到中斷事件的發生)
• 線程終結規則：線程中所有操作都先行發生于線程的終止檢測，我們可以通過 Thread.join()方法結束， Thread.isAlive()的返回值手段檢測到線程已經終止執行
• 對象終結規則：一個對象的初始化完成先行發生于他的 finalize()方法的開始

六、線程安全性：總結

• 原子性：Atomic包、CAS算法、synchronized、Lock
• 可見性：synchronized、volatile

一個主內存的線程如果進行了修改，可以及時被其他線程觀察到，介紹了volatile如何被觀察到的

• 有序性：happens-before原則 happens-before原則，觀察結果，如果兩個線程不能偶從happens-before原則觀察出來，那么就不能觀察他們的有序性，虛擬機可以隨意的對他們進行重排序