死磕 java併發包之AtomicStampedReference源碼分析（ABA問題詳解）

時間  2019-11-24
標籤 java 併發 atomicstampedreference 源碼 分析 aba 問題 詳解 欄目 Java 简体版
原文   原文鏈接

問題

（1）什麼是ABA？java

（2）ABA的危害？node

（3）ABA的解決方法？git

（4）AtomicStampedReference是什麼？安全

（5）AtomicStampedReference是怎麼解決ABA的？服務器

簡介

AtomicStampedReference是java併發包下提供的一個原子類，它能解決其它原子類沒法解決的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；

ABA

能夠看到，針對線程1來講，第一次的A和第二次的A實際上並非同一個A。

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

public class ABATest {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(()->{
            int value = atomicInteger.get();
            System.out.println("thread 1 read value: " + value);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);

            if (atomicInteger.compareAndSet(value, 3)) {
                System.out.println("thread 1 update from " + value + " to 3");
            } else {
                System.out.println("thread 1 update fail!");
            }
        }).start();

        new Thread(()->{
            int value = atomicInteger.get();
            System.out.println("thread 2 read value: " + value);
            if (atomicInteger.compareAndSet(value, 2)) {
                System.out.println("thread 2 update from " + value + " to 2");

                // do sth

                value = atomicInteger.get();
                System.out.println("thread 2 read value: " + value);
                if (atomicInteger.compareAndSet(value, 1)) {
                    System.out.println("thread 2 update from " + value + " to 1");
                }
            }
        }).start();
    }
}
複製代碼

打印結果爲：

thread 1 read value: 1
thread 2 read value: 1
thread 2 update from 1 to 2
thread 2 read value: 2
thread 2 update from 2 to 1
thread 1 update from 1 to 3
複製代碼

ABA的危害

爲了更好地理解ABA的危害，咱們仍是來看一個現實點的例子。

假設咱們有一個無鎖的棧結構，以下：

public class ABATest {

    static class Stack {
        // 將top放在原子類中
        private AtomicReference<Node> top = new AtomicReference<>();
        // 棧中節點信息
        static class Node {
            int value;
            Node next;

            public Node(int value) {
                this.value = value;
            }
        }
        // 出棧操做
        public Node pop() {
            for (;;) {
                // 獲取棧頂節點
                Node t = top.get();
                if (t == null) {
                    return null;
                }
                // 棧頂下一個節點
                Node next = t.next;
                // CAS更新top指向其next節點
                if (top.compareAndSet(t, next)) {
                    // 把棧頂元素彈出，應該把next清空防止外面直接操做棧
                    t.next = null;
                    return t;
                }
            }
        }
        // 入棧操做
        public void push(Node node) {
            for (;;) {
                // 獲取棧頂節點
                Node next = top.get();
                // 設置棧頂節點爲新節點的next節點
                node.next = next;
                // CAS更新top指向新節點
                if (top.compareAndSet(next, node)) {
                    return;
                }
            }
        }
    }
}
複製代碼

咋一看，這段程序彷佛沒有什麼問題，然而試想如下情形。

假如，咱們初始化棧結構爲 top->1->2->3，而後有兩個線程分別作以下操做：

（1）線程1執行pop()出棧操做，可是執行到if (top.compareAndSet(t, next)) {這行以前暫停了，因此此時節點1並未出棧；

（2）線程2執行pop()出棧操做彈出節點1，此時棧變爲 top->2->3；

（3）線程2執行pop()出棧操做彈出節點2，此時棧變爲 top->3；

（4）線程2執行push()入棧操做添加節點1，此時棧變爲 top->1->3；

（5）線程1恢復執行，比較節點1的引用並無改變，執行CAS成功，此時棧變爲 top->2；

What？點解變成 top->2 了？不是應該變成 top->3 嗎？

那是由於線程1在第一步保存的next是節點2，因此它執行CAS成功後top節點就指向了節點2了。

測試代碼以下：

private static void testStack() {
    // 初始化棧爲 top->1->2->3
    Stack stack = new Stack();
    stack.push(new Stack.Node(3));
    stack.push(new Stack.Node(2));
    stack.push(new Stack.Node(1));

    new Thread(()->{
        // 線程1出棧一個元素
        stack.pop();
    }).start();

    new Thread(()->{
        // 線程2出棧兩個元素
        Stack.Node A = stack.pop();
        Stack.Node B = stack.pop();
        // 線程2又把A入棧了
        stack.push(A);
    }).start();
}

public static void main(String[] args) {
    testStack();
}
複製代碼

在Stack的pop()方法的if (top.compareAndSet(t, next)) {處打個斷點，線程1運行到這裏時阻塞它的執行，讓線程2執行完，再執行線程1這句，這句執行完能夠看到棧的top對象中只有2這個節點了。

記得打斷點的時候必定要打Thread斷點，在IDEA中是右擊選擇Suspend爲Thread。

經過這個例子，筆者認爲你確定很清楚ABA的危害了。

ABA的解決方法

ABA的危害咱們清楚了，那麼怎麼解決ABA呢？

筆者總結了一下，大概有如下幾種方式：

（1）版本號

好比，上面的棧結構增長一個版本號用於控制，每次CAS的同時檢查版本號有沒有變過。

還有一些數據結構喜歡使用高位存儲一個郵戳來保證CAS的安全。

（2）不重複使用節點的引用

好比，上面的棧結構在線程2執行push()入棧操做的時候新建一個節點傳入，而不是複用節點1的引用；

（3）直接操做元素而不是節點

好比，上面的棧結構push()方法不該該傳入一個節點（Node），而是傳入元素值（int的value）。

好了，扯了這麼多，讓咱們來看看java中的AtomicStampedReference是怎麼解決ABA的吧^^

源碼分析

內部類

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（郵票、戳的意思）中。

屬性

private volatile Pair<V> pair;
private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
private static final long pairOffset =
    objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
複製代碼

聲明一個Pair類型的變量並使用Unsfae獲取其偏移量，存儲到pairOffset中。

構造方法

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 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。

能夠看到，java中的實現跟咱們上面講的ABA的解決方法是一致的。

首先，使用版本號控制；

其次，不重複使用節點（Pair）的引用，每次都新建一個新的Pair來做爲CAS比較的對象，而不是複用舊的；

最後，外部傳入元素值及版本號，而不是節點（Pair）的引用。

案例

讓咱們來使用AtomicStampedReference解決開篇那個AtomicInteger帶來的ABA問題。

public class ABATest {

    public static void main(String[] args) {
        testStamp();
    }

    private static void testStamp() {
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("thread 1 read value: " + value + ", stamp: " + stamp);

            // 阻塞1s
            LockSupport.parkNanos(1000000000L);

            if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp + 1)) {
                System.out.println("thread 1 update from " + value + " to 3");
            } else {
                System.out.println("thread 1 update fail!");
            }
        }).start();

        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("thread 2 read value: " + value + ", stamp: " + stamp);
            if (atomicStampedReference.compareAndSet(value, 2, stamp, stamp + 1)) {
                System.out.println("thread 2 update from " + value + " to 2");

                // do sth

                value = atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                System.out.println("thread 2 read value: " + value + ", stamp: " + stamp);
                if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp + 1)) {
                    System.out.println("thread 2 update from " + value + " to 1");
                }
            }
        }).start();
    }
}
複製代碼

運行結果爲：

thread 1 read value: 1, stamp: 1
thread 2 read value: 1, stamp: 1
thread 2 update from 1 to 2
thread 2 read value: 2, stamp: 2
thread 2 update from 2 to 1
thread 1 update fail!
複製代碼

能夠看到線程1最後更新1到3時失敗了，由於這時版本號也變了，成功解決了ABA的問題。

總結

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

（2）ABA的解決通常使用版本號來控制，並保證數據結構使用元素值來傳遞，且每次添加元素都新建節點承載元素值；

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

彩蛋

（1）java中還有哪些類能夠解決ABA的問題？

AtomicMarkableReference，它不是維護一個版本號，而是維護一個boolean類型的標記，標記值有修改，瞭解一下。

（2）實際工做中遇到過ABA問題嗎？

筆者還真遇到過，之前作棋牌遊戲的時候，ABCD四個玩家，A玩家出了一張牌，而後他這個請求遲遲沒到服務器，也就是超時了，服務器就幫他自動出了一張牌。

而後，轉了一圈，又輪到A玩家出牌了，說巧不巧，正好這時以前那個請求到了服務器，服務器檢測到如今正好是A出牌，並且請求的也是出牌，就把這張牌打出去了。

而後呢，A玩家的牌就不對了。

最後，咱們是經過給每一個請求增長一個序列號來處理的，檢測到過時的序列號請求直接拋棄掉。

你有沒有遇到過ABA問題呢？

歡迎關注個人公衆號「彤哥讀源碼」，查看更多源碼系列文章, 與彤哥一塊兒暢遊源碼的海洋。

qrcode
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程