【JDK原始碼】并發原子類AtomicStampedReference

簡介

AtomicStampedReference是java并發包下提供的一個原子類，它能解決其它原子類無法解決的ABA問題，比如AtomicInteger存在ABA問題

ABA

ABA問題發生在多執行緒環境中，當某執行緒連續讀取同一塊記憶體地址兩次，兩次得到的值一樣，它簡單地認為“此記憶體地址的值并沒有被修改過”，然而，同時可能存在另一個執行緒在這兩次讀取之間把這個記憶體地址的值從A修改成了B又修改回了A，這時還簡單地認為“沒有修改過”顯然是錯誤的，

比如，兩個執行緒按下面的順序執行：

（1）執行緒1讀取記憶體位置X的值為A；

（2）執行緒1阻塞了；

（3）執行緒2讀取記憶體位置X的值為A；

（4）執行緒2修改記憶體位置X的值為B；

（5）執行緒2修改又記憶體位置X的值為A；

（6）執行緒1恢復，繼續執行，比較發現還是A把記憶體位置X的值設定為C；

可以看到，針對執行緒1來說，第一次的A和第二次的A實際上并不是同一個A，

ABA問題通常發生在無鎖結構中，用代碼來表示上面的程序大概就是這樣：

public static void main(String[] args) {
    AtomicInteger atomicInteger = new AtomicInteger(1);
    new Thread(new Runnable() {
        @Override
        public void run() {
            int value = atomicInteger.get();
            System.out.println("執行緒1讀到value="+value);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (atomicInteger.compareAndSet(value,3)) {
                System.out.println("執行緒1修改value從"+value+"到3");
            }
        }
    }).start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            int value = atomicInteger.get();
            System.out.println("執行緒2讀到value="+value);
            if (atomicInteger.compareAndSet(value,2)) {
                System.out.println("執行緒2修改value從"+value+"到2");

                value = atomicInteger.get();
                System.out.println("執行緒2讀到value="+value);
                if (atomicInteger.compareAndSet(value,1)){
                    System.out.println("執行緒2修改value從"+value+"到1");
                }
            }
        }
    }).start();
}

輸出

執行緒1讀到value=1
執行緒2讀到value=1
執行緒2修改value從1到2
執行緒2讀到value=2
執行緒2修改value從2到1
執行緒1修改value從1到3

內部類

AtomicStampedReference

private static class Pair<T> {
    final T reference;// 元素值
    final int stamp;  // 版本號
    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }
    static <T> Pair<T> of(T reference, int stamp) {
        return new Pair<T>(reference, stamp);
    }
}

將元素值和版本號系結在一起，存盤在Pair的reference和stamp（郵票、戳的意思）中，

構造方法

public AtomicStampedReference(V initialRef, int initialStamp) {
    // 也就是初始化的時候必須傳入元素值和版本號
    pair = Pair.of(initialRef, initialStamp);
}

compareAndSet()方法

public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp) {
    // 獲取當前的（元素值和版本號）對
    Pair<V> current = pair;
    return
        // 元素沒變
        expectedReference == current.reference &&
        // 版本號沒變
        expectedStamp == current.stamp &&
        // 新參考等于舊參考
        ((newReference == current.reference &&
          // 新版本號等于舊版本號
          newStamp == current.stamp) ||
         // 構造新的Pair物件并CAS更新
         casPair(current, Pair.of(newReference, newStamp)));
}

private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
private static final long pairOffset =
    objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);

private boolean casPair(Pair<V> cmp, Pair<V> val) {
    // 呼叫Unsafe的compareAndSwapObject()方法CAS更新pair的參考為新參考
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

（1）如果元素值和版本號都沒有變化，并且和新的也相同，回傳true；

（2）如果元素值和版本號都沒有變化，并且和新的不完全相同，就構造一個新的Pair物件并執行CAS更新pair，

• AtomicStampedReference采用版本號來解決ABA

案例

使用AtomicStampedReference解決那個AtomicInteger帶來的ABA問題

public static void main(String[] args) {
    AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1,1);
    int[] stampHolder = new int[1];

    new Thread(new Runnable() {
        @Override
        public void run() {
            int  value = atomicInteger.get(stampHolder);
            // 一定要先保存原來的值
            int stamp = stampHolder[0];
            System.out.println("執行緒1讀到value="+value+"、stamp="+stampHolder[0]);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("執行緒1讀到value="+value+"、stamp="+stampHolder[0]);
            // 這里變成stamp是為了傳入之前的值，如果是stampHolder[0]則是最新的值也就沒有意義了
            if (atomicInteger.compareAndSet(value,3,stamp,stampHolder[0]+1)) {
                System.out.println("執行緒1修改value從"+value+"到3、"+"stamp從"+stampHolder[0]+"到"+(stampHolder[0]+1));
            }else{
                System.out.println("執行緒1修改失敗");
            }
        }
    }).start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            int  value = atomicInteger.get(stampHolder);
            System.out.println("執行緒2讀到value="+value+"、stamp="+stampHolder[0]);
            if (atomicInteger.compareAndSet(value,2,stampHolder[0],stampHolder[0]+1)) {
                System.out.println("執行緒2修改value從"+value+"到2、"+"stamp從"+stampHolder[0]+"到"+(stampHolder[0]+1));

                value = atomicInteger.get(stampHolder);
                System.out.println("執行緒2讀到value="+value+"、stamp="+stampHolder[0]);
                if (atomicInteger.compareAndSet(value,1,stampHolder[0],stampHolder[0]+1)){
                    System.out.println("執行緒2修改value從"+value+"到1、"+"stamp從"+stampHolder[0]+"到"+(stampHolder[0]+1));
                    value = atomicInteger.get(stampHolder);
                    System.out.println("執行緒2讀到value="+value+"、stamp="+stampHolder[0]);
                }
            }
        }
    }).start();
}

可以看到執行緒1最后更新1到3時失敗了，因為這時版本號也變了，成功解決了ABA的問題，

執行緒2讀到value=1、stamp=1
執行緒1讀到value=1、stamp=1
執行緒2修改value從1到2、stamp從1到2
執行緒2讀到value=2、stamp=2
執行緒2修改value從2到1、stamp從2到3
執行緒2讀到value=1、stamp=3
執行緒1讀到value=1、stamp=3
執行緒1修改失敗

總結

（1）在多執行緒環境下使用無鎖結構要注意ABA問題；

（2）ABA的解決一般使用版本號來控制，并保證資料結構使用元素值來傳遞，且每次添加元素都新建節點承載元素值；

（3）AtomicStampedReference內部使用Pair來存盤元素值及其版本號；