CAS與ABA問題產生和解決

樂觀鎖和悲觀鎖

Synchronized屬於悲觀鎖，悲觀地認為程序中的並發情況嚴重，所以嚴防死守。CAS屬於樂觀鎖，樂觀地認為程序中的並發情況不那么嚴重，所以讓線程不斷去嘗試更新。

性能對比：
Synchronized關鍵字會讓沒有得到鎖資源的線程進入blocked狀態，而后在爭奪到鎖資源后恢復為runnable狀態，這個過程中涉及到操作系統用戶模式和內核模式的轉換，代價比較高。

盡管Java1.6為Synchronized做了優化，增加了從偏向鎖到輕量級鎖再到重量級鎖的過度，但是在最終轉變為重量級鎖之后，性能仍然較低。

CAS原理

CAS機制當中使用了3個基本操作數：內存地址V，舊的預期值A，要修改的新值B。
更新一個變量的時候，只有當變量的預期值A和內存地址V當中的實際值相同時，才會將內存地址V對應的值修改為B。

CAS缺點：

1. CPU開銷較大，多線程反復嘗試更新某一個變量的時候容易出現；
2. 不能保證代碼塊的原子性，只能保證變量的原子性操作；
3. ABA問題。

CAS機制：

AtomicInteger當中常用的自增方法 incrementAndGet：

public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
    }
}
private volatile int value;
public final int get() {
return value;
}

CAS的自旋。循環體當中做了三件事：
1.獲取當前值。
2.當前值+1，計算出目標值。
3.進行CAS操作，如果成功則跳出循環，如果失敗則重復上述步驟。

ABA問題以及解決方案：

因為CAS需要在操作值的時候檢查下值有沒有發生變化，如果沒有發生變化則更新，但是如果一個值原來是A，變成了B，又變成了A，那么使用CAS進行檢查時會發現它的值沒有發生變化，但是實際上卻變化了。ABA問題的解決思路就是使用版本號。在變量前面追加上版本號，每次變量更新的時候把版本號加一，那么A－B－A 就會變成1A-2B－3A。 從Java1.5開始JDK的atomic包里提供了一個類AtomicStampedReference來解決ABA問題。這個類的compareAndSet方法作用是首先檢查當前引用是否等於預期引用，並且當前標志是否等於預期標志，如果全部相等，則以原子方式將該引用和該標志的值設置為給定的更新值。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABA {
        private static AtomicInteger atomicInt = new AtomicInteger(100);
        private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(100, 0);
        public static void main(String[] args) throws InterruptedException {
                Thread intT1 = new Thread(new Runnable() {
                        @Override
                        public void run() {
                                atomicInt.compareAndSet(100, 101);
                                atomicInt.compareAndSet(101, 100);
                        }
                });
                Thread intT2 = new Thread(new Runnable() {
                        @Override
                        public void run() {
                                try {
                                        TimeUnit.SECONDS.sleep(1);
                                } catch (InterruptedException e) {
                                }
                                boolean c3 = atomicInt.compareAndSet(100, 101);
                                System.out.println(c3); // true
                        }
                });
                intT1.start();
                intT2.start();
                intT1.join();
                intT2.join();
                Thread refT1 = new Thread(new Runnable() {
                        @Override
                        public void run() {
                                try {
                                        TimeUnit.SECONDS.sleep(1);
                                } catch (InterruptedException e) {
                                }
                                atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
                                atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
                        }
                });
                Thread refT2 = new Thread(new Runnable() {
                        @Override
                        public void run() {
                                int stamp = atomicStampedRef.getStamp();
                                try {
                                        TimeUnit.SECONDS.sleep(2);
                                } catch (InterruptedException e) {
                                }
                                boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
                                System.out.println(c3); // false
                        }
                });
                refT1.start();
                refT2.start();
        }
}