## 樂觀鎖 一般而言，在併發情況下我們必須通過一定的手段來保證資料的準確性，如果沒有做好併發控制，就可能導致髒讀、幻讀和不可重複度等一系列問題。樂觀鎖是人們為了應付併發問題而提出的一種思想，具體的實現則有多種方式。 樂觀鎖假設資料一般情況下不會造成衝突，只在資料進行提交更新時，才會正式對資料的衝突與否進行檢測，如果發現衝突了，則返回給使用者錯誤的資訊，讓使用者決定如何去做。樂觀鎖適用於讀操作多的場景，可以提高程式的吞吐量。
## CAS CAS（Compare And Swap）比較並交換，是一種實現了樂觀鎖思想的併發控制技術。CAS 演算法的過程是：它包含 3 個引數 CAS（V，E，N），V 表示要更新的變數（記憶體值），E 表示舊的預期值，N 表示即將更新的預期值。當且僅當 V 值等於 E 值時，才會將 V 的值設為 N，如果 V 值和 E 值不同，說明已經有其他執行緒做了更新，則當前執行緒什麼也不做，並返回當前 V 的真實值。整個操作是原子性的。 當多個執行緒同時使用 CAS 操作一個變數時，只有一個會勝出，併成功更新，其餘均會失敗。失敗的執行緒不會被掛起，僅是被告知失敗，並允許再次嘗試，當然也可以放棄本次操作，所以 CAS 演算法是非阻塞的。基於上述原理，CAS 操作可以在不借助鎖的情況下實現合適的併發處理。
## ABA 問題 ABA 問題是 CAS 演算法的一個漏洞。CAS 演算法實現的一個重要前提是：取出記憶體中某時刻的資料，並在下一時刻比較並替換，在這個時間差內可能會導致資料的變化。 假設有兩個執行緒，分別要對記憶體中某一變數做 CAS 操作，執行緒一先從記憶體中取出值 A，執行緒二也從記憶體中取出值 A，並把值從 A 變為 B 寫回，然後又把值從 B 變為 A 寫回，這時候執行緒一進行 CAS 操作，發現記憶體中的值還是 A，於是認為和預期值一致，操作成功。儘管執行緒一的 CAS 操作成功，但並不代表這個過程就沒有問題。 ABA 問題會帶來什麼隱患呢？維基百科給出了詳細的示例：假設現有一個用單鏈表實現的堆疊，棧頂為 A，A.next = B，現有執行緒一希望用 CAS 把棧頂替換為 B，但在此之前，執行緒二介入，將 A、B 出棧，再壓入 D、C、A，整個過程如下  此時 B 處於遊離轉態，輪到執行緒一執行 CAS 操作，發現棧頂仍為 A，CAS 成功，棧頂變為 B，但實際上 B.next = null，即堆疊中只有 B 一個元素，C 和 D 並不在堆疊中，平白無故就丟了。簡單來說，ABA 問題使我們漏掉某一段時間的資料監控，誰知道在這段時間內會發生什麼有趣（可怕）的事呢？ 可以通過版本號的方式來解決 ABA 問題，每次執行資料修改操作時，都會帶上一個版本號，如果版本號和資料的版本一致，對資料進行修改操作並對版本號 +1，否則執行失敗。因為每次操作的版本號都會隨之增加，所以不用擔心出現 ABA 問題。
## 使用 Java 模擬 CAS 演算法 這僅僅是基於 Java 層面上的模擬，真正的實現要涉及到底層（我學不會） ```java public class TestCompareAndSwap { private static CompareAndSwap cas = new CompareAndSwap(); public static void main(String[] args) { for (int i = 0; i < 10; i++) { new Thread(new Runnable() { public void run() { // 獲取預估值 int expectedValue = cas.get(); boolean b = cas.compareAndSet(expectedValue, (int) (Math.random() * 101)); System.out.println(b); } }); } } } class CompareAndSwap { private int value; // 獲取記憶體值 public synchronized int get() { return value; } // 比較 public synchronized int compareAndSwap(int expectedValue, int newValue) { // 讀取記憶體值 int oldValue = value; // 比較 if (oldValue == expectedValue) { this.value = newValue; } return oldValue; } // 設定 public synchronized boolean compareAndSet(int expectedValue, int newValue) { return expectedValue == compareAndSwap(expectedValue, newValue); } } ```
## 原子類 原子包 java.util.concurrent.atomic 提供了一組原子類，原子類的操作具有原子性，一旦開始，就一直執行直到結束，中間不會有任何執行緒上下文切換。原子類的底層正是基於 CAS 演算法實現執行緒安全。 Java 為我們提供了十六個原子類，可以大致分為以下四種： #### 1. 基本型別 - AtomicBoolean 原子更新布林型別，內部使用 int 型別的 value 儲存 1 和 0 表示 true 和 false，底層也是對 int 型別的原子操作 - AtomicInteger 原子更新 int 型別 - AtomicLong 原子更新 long 型別 #### 2. 引用型別 - AtomicReference 原子更新引用型別，通過泛型指定要操作的類 - AtomicMarkableReference 原子更新引用型別，內部維護一個 Pair 型別（靜態內部類）的成員屬性，其中有一個 boolean 型別的標誌位，避免 ABA 問題 ```java private static class Pair { final T reference; final boolean mark; private Pair(T reference, boolean mark) { this.reference = reference; this.mark = mark; } static Pair of(T reference, boolean mark) { return new Pair(reference, mark); } } private volatile Pair pair; ``` - AtomicStampedReference 原子更新引用型別，內部維護一個 Pair 型別（靜態內部類）的成員屬性，其中有一個 int 型別的郵戳（版本號），避免 ABA 問題 ```java private static class Pair { final T reference; final int stamp; private Pair(T reference, int stamp) { this.reference = reference; this.stamp = stamp; } static Pair of(T reference, int stamp) { return new Pair(reference, stamp); } } private volatile Pair pair; ``` #### 3. 陣列型別 - AtomicIntegerArray 原子更新 int 陣列中的元素 - AtomicLongArray 原子更新 long 陣列中的元素 - AtomicReferenceArray 原子更新 Object 陣列中的元素 #### 4. 物件屬性型別 用於解決物件的屬性的原子操作 - AtomicIntegerFieldUpdater 原子更新物件中的 int 型別欄位 - AtomicLongFieldUpdater 原子更新物件中的 long 型別欄位 - AtomicReferenceFieldUpdater 原子更新物件中的引用型別欄位 之前提到的三種類型的使用都比較簡單，查閱對應 API 即可，而物件屬性型別則有一些限制： - 欄位必須是 volatile 型別的，線上程之間共享變數時保證立即可見 - 只能是例項變數，不能是類變數，也就是說不能加 static 關鍵字 - 只能是可修改變數，不能使用 final 變數 - 該物件欄位能夠被直接操作，因為它是基於反射實現的 #### 5. 高效能原子類 Java8 新增的原子類，使用分段的思想，把不同的執行緒 hash 到不同的段上去更新，最後再把這些段的值相加得到最終的值。以下四個類都繼承自 Striped64，對併發的優化在 Striped64 中實現  - LongAccumulator long 型別的聚合器，需要傳入一個 long 型別的二元操作，可以用來計算各種聚合操作，包括加乘等 - LongAdder long 型別的累加器，LongAccumulator 的特例，只能用來計算加法，且從 0 開始計算 - DoubleAccumulator double 型別的聚合器，需要傳入一個 double 型別的二元操作，可以用來計算各種聚合操作，包括加乘等 - DoubleAdder double 型別的累加器，DoubleAccumulator 的特例，只能用來計算加法，且從 0 開始計