CAS底層原理與ABA問題

CAS定義

CAS(Compare And Swap)是一種無鎖算法。CAS算法是樂觀鎖的一種實現。CAS有3個操作數，內存值V，舊的預期值A，要修改的新值B。當預期值A和內存值V相同時，將內存值V修改爲B並返回true，否則返回false。

CAS與synchronized

（1）synchronized加鎖，同一時間段只允許一個線程訪問，能夠保證一致性但是併發性下降。

（2）CAS是一個自旋鎖算法，使用do-while不斷判斷（沒有加鎖），保證一致性和併發性，但是比較消耗CPU資源。使用CAS就可以不用加鎖來實現線程安全。

• 原子性保證：CAS算法依賴於rt.jar包下的sun.misc.Unsafe類，該類中的所有方法都是native修飾的，直接調用操作系統底層資源執行相應的任務。
• 內存可見性和禁止指令重排序的保證：AtomicXxx類中的成員變量value是由volatile修飾的：private volatile int value;

CAS算法的缺點

CAS雖然很高效的解決了原子操作問題，但是CAS仍然存在三大問題。

• 循環時間長、開銷很大。

當某一方法比如：getAndAddInt執行時，如果CAS失敗，會一直進行嘗試。如果CAS長時間嘗試但是一直不成功，可能會給CPU帶來很大的開銷。

• 只能保證一個共享變量的原子操作。

當操作1個共享變量時，我們可以使用循環CAS的方式來保證原子操作，但是操作多個共享變量時，循環CAS就無法保證操作的原子性，這個時候就需要用鎖來保證原子性。

• 存在ABA問題

如果一個線程在初次讀取時的值爲A，並且在賦值的時候檢查該值仍然是A，但是可能在這兩次操作，之間有另外一個線程現將變量的值改成了B，然後又將該值改回爲A，那麼CAS會誤認爲該變量沒有變化過。

CAS底層原理

sum.misc.Unsafe類中有多個方法被native關鍵字標記，這說明該方法是原生態的方法，它是一個調用非java語言的接口，也就是說這個接口的實現是其他語言實現的。CAS併發原語就是體現在java的sum.misc.Unsafe類中的各個方法，調用這個類中的CAS方法JVM就會通過其他語言生成若干條系統指令，完整這些指令的過程中，是不允許被中斷的，所以CAS是一條CUP的原子指令，所以它不會造成數據不一致問題。

多線程情況下，number變量每次++都會出現線程安全問題，AtomicInteger則不會，因爲它保證了原子性。

 我們進去看，getAndIncrement調用的就是Unsafe類中的getAndAddInt方法，this表示當前對象，valueOffset表示變量值在內存中的偏移量（也就是內存地址）

我們再進入Unsafe類看看var1就是getAndIncrement方法傳過來的對象，var2是系統偏移量，這裏是使用了do-while循環，一開始循環就通過var1對象和var2偏移量獲取期望值var5，進入循環，compareAndSwapInt方法被native關鍵字標記的，所以他是原子性的 ，var2的值與var的值相等時，則使用新的值var5+var4，返回true，循環條件取反則結束循環，否則如果var2與var5不相等就繼續循環，直到條件不滿足再跳出循環

// unsafe.class
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        // 獲取對象var1，偏移量爲var2地址上的值，並賦值給var5
        var5 = this.getIntVolatile(var1, var2);
        /**
         * 再次獲取對象var1，偏移量var2地址上的值，並和var5進行比較：
         * - 如果不相等，返回false，繼續執行do-while循環
         * - 如果相等，將返回的var5數值和var4相加並返回
         */
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    // 最終總是返回對象var1，偏移量爲var2地址上的值，即上述所說的V。
    return var5;
}

ABA問題解決方案

使用AtomicStampedReference或者AtomicMarkableReference來解決CAS的ABA問題，思路類似於SVN版本號，SpringBoot熱部署中trigger.txt

AtomicStampedReference解決方案：每次修改都會讓stamp值加1，類似於版本控制號

package com.raicho.mianshi.mycas;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author: Raicho
 * @Description:
 * @program: mianshi
 * @create: 2020-07-17 10:19
 **/
public class AtomicStampedReferenceABA {
    private static AtomicReference<Integer> ar = new AtomicReference<>(0);
    private static AtomicStampedReference<Integer> asr =
            new AtomicStampedReference<>(0, 1);

    public static void main(String[] args) {
        System.out.println("=============演示ABA問題（AtomicReference）===========");
        new Thread(() -> {
            ar.compareAndSet(0, 1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ar.compareAndSet(1, 0);
            System.out.println(Thread.currentThread().getName() + "進行了一次ABA操作");
        }, "子線程").start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        boolean res = ar.compareAndSet(0, 100);
        if (res) {
            System.out.println("main成功修改, 未察覺到子線程進行了ABA操作");
        }

        System.out.println("=============解決ABA問題（AtomicStampReference）===========");
        new Thread(() -> {
            int curStamp = asr.getStamp();
            System.out.println("t1獲取當前stamp: " + curStamp);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            asr.compareAndSet(0, 1, curStamp, curStamp + 1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            asr.compareAndSet(1, 0, asr.getStamp(), asr.getStamp() + 1);
        }, "t1").start();

        new Thread(() -> {
            int curStamp = asr.getStamp();
            System.out.println("t2獲取當前stamp: " + curStamp);
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean result = asr.compareAndSet(0, 100, curStamp, curStamp + 1);
            if (!result) {
                System.out.println("修改失敗! 預期stamp: " + curStamp + ", 實際stamp: " + asr.getStamp());
            }
        }, "t2").start();
    }
}

運行結果：

AtomicMarkableReference：如果不關心引用變量中途被修改了多少次，而只關心是否被修改過，可以使用AtomicMarkableReference：

package com.raicho.mianshi.mycas;

import java.util.concurrent.atomic.AtomicMarkableReference;

/**
 * @author: Raicho
 * @Description:
 * @program: mianshi
 * @create: 2020-07-17 10:46
 **/
public class AtomicMarkableReferenceABA {
    private static AtomicMarkableReference<Integer> amr = new AtomicMarkableReference<>(0, false);

    public static void main(String[] args) {
        new Thread(() -> {
            amr.compareAndSet(0, 1, false, true);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            amr.compareAndSet(1, 0, true, true);
            System.out.println("子線程進行了ABA修改!");
        }, "子線程").start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        boolean res = amr.compareAndSet(0, 100, false, true);
        if (!res) {
            System.out.println("修改失敗! 當前isMarked: " + amr.isMarked());
        }
    }
}

運行結果：

參考

知乎：https://zhuanlan.zhihu.com/p/93418208

csdn：https://blog.csdn.net/justry_deng/article/details/83449038