Java CAS原子操作詳解

更新時間：2023年02月02日 10:44:07 作者：飛奔的小付

在synchronized的優(yōu)化過程中我們看到大量使用了CAS操作，CAS全稱Compare And Set（或Compare And Swap），簡單來說CAS操作就是一個虛擬機實現(xiàn)的原子操作

一.什么是CAS

CAS（Compare And Swap，比較并交換），通常指的是這樣一種原子操作：針對一個變量，首先比較它的內(nèi)存值與某個期望值是否相同，如果相同，就給它賦一個新值。

CAS是一個不可分割的原子操作，并且其原子性是直接在硬件層面得到保障的。
CAS是樂觀鎖（對比數(shù)據(jù)庫的悲觀、樂觀鎖）的一種實現(xiàn)方式，Java原子類中的遞增操作就通過CAS自旋實現(xiàn)的。
CAS是一種無鎖算法，在不使用鎖（沒有線程被阻塞）的情況下實現(xiàn)多線程之間的變量同步。

二.流程

三.應(yīng)用

在 Java 中，CAS 操作是由 Unsafe 類提供支持的，該類定義了三種針對不同類型變量的 CAS 操作

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

它們都是 native 方法，由 Java 虛擬機提供具體實現(xiàn)，這意味著不同的 Java 虛擬機對它們的實現(xiàn)可能會略有不同。

以compareAndSwapInt為例，該方法提供四個參數(shù)，分別是：對象實例、內(nèi)存偏移量、字段期望值、字段新值。該方法會針對指定對象實例中的相應(yīng)偏移量的字段執(zhí)行 CAS 操作。

public class CASTest {
    public static void main(String[] args) {
        Entity entity = new Entity();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");
        //12
        System.out.println(offset);
        boolean successful;
        // 4個參數(shù)分別是：對象實例、字段的內(nèi)存偏移量、字段期望值、字段更新值
        //x是不是等于0，如果等于0就把它修改為3
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "-----" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "-----" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "-----" + entity.x);
    }
}
class Entity{
    int x;
}
public class UnsafeFactory {
    /**
     * 獲取 Unsafe 對象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 獲取字段的內(nèi)存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

將x做了三次修改，執(zhí)行結(jié)果是：

12

true-----3

true-----5

false-----5

四.源碼解析

Hotspot 虛擬機對compareAndSwapInt 方法的實現(xiàn)如下：

#unsafe.cpp 
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jo bject obj, jlong offset, jint e, jint x)) 
UnsafeWrapper("Unsafe_CompareAndSwapInt"); 
oop p = JNIHandles::resolve(obj); 
// 根據(jù)偏移量，計算value的地址 
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
// Atomic::cmpxchg(x, addr, e) cas邏輯 x:要交換的值 e:要比較的值 
//cas成功，返回期望值e，等于e,此方法返回true 
//cas失敗，返回內(nèi)存中的value值，不等于e，此方法返回false 
return (jint)(Atomic::cmpxchg(x, addr, e)) == e; 
UNSAFE_END

核心邏輯在Atomic::cmpxchg方法中，這個根據(jù)不同操作系統(tǒng)和不同CPU會有不同的實現(xiàn)。這里我們以linux_64x的為例，查看Atomic::cmpxchg的實現(xiàn)

#atomic_linux_x86.inline.hpp 
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint com pare_value) { 
 //判斷當(dāng)前執(zhí)行環(huán)境是否為多處理器環(huán)境 
 int mp = os::is_MP(); 
 //LOCK_IF_MP(%4)在多處理器環(huán)境下，為cmpxchgl指令添加lock前綴，以達到內(nèi)存屏障的效果 
  //cmpxchgl 指令是包含在 x86 架構(gòu)及 IA‐64 架構(gòu)中的一個原子條件指令， 
  //它會首先比較 dest 指針指向的內(nèi)存值是否和 compare_value 的值相等， 
  //如果相等，則雙向交換 dest 與 exchange_value，否則就單方面地將dest指向的內(nèi)存值交給exchange_value。 
  //這條指令完成了整個CAS操作，因此它也被稱為CAS指令。 
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)" 
  : "=a" (exchange_value) 
  : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp) 
  : "cc", "memory"); 
  return exchange_value; 
  }

需要注意的是cmpxchg有個隱含操作數(shù)eax，其實際過程是先比較eax的值(也就是 compare_value)和dest地址所存的值是否相等，輸出是"=a" (exchange_value)，表示把eax中存的值寫入exchange_value變量中。

Atomic::cmpxchg這個函數(shù)最終返回值是exchange_value，也就是說，如果cmpxchgl執(zhí)行時compare_value和dest指針指向內(nèi)存值相等則會使得dest指針指向內(nèi)存值變成 exchange_value，最終eax存的compare_value賦值給了exchange_value變量，即函數(shù)最終返回的值是原先的compare_value。此時Unsafe_CompareAndSwapInt的返回值(jint) (Atomic::cmpxchg(x, addr, e)) == e就是true，表明CAS成功。如果cmpxchgl執(zhí)行時 compare_value和(dest)不等則會把當(dāng)前dest指針指向內(nèi)存的值寫入eax，最終輸出時賦值給exchange_value變量作為返回值，導(dǎo)致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到 false，表明CAS失敗。

不管是 Hotspot 中的 Atomic::cmpxchg 方法，還是 Java 中的 compareAndSwapInt 方法，它們本質(zhì)上都是對相應(yīng)平臺的 CAS 指令的一層簡單封裝。CAS 指令作為一種硬件原語，有著天然的原子性，這也正是 CAS 的價值所在。

五.缺點

CAS 雖然高效地解決了原子操作，但是還是存在一些缺陷的，主要表現(xiàn)在三個方面：

自旋 CAS 長時間地不成功，則會給 CPU 帶來非常大的開銷
只能保證一個共享變量原子操作
ABA 問題

六.ABA 問題及解決方案

CAS算法實現(xiàn)一個重要前提需要取出內(nèi)存中某時刻的數(shù)據(jù)，而在下時刻比較并替換，那么在這個時間差類會導(dǎo)致數(shù)據(jù)的變化。

當(dāng)有多個線程對一個原子類進行操作的時候，某個線程在短時間內(nèi)將原子類的值A(chǔ)修改為B，又馬上將其修改為A，此時其他線程不感知，還是會修改成功。

代碼演示

public class ABATest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);
        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread1 read value: " + value);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通過CAS修改value值為3
            if (atomicInteger.compareAndSet(value, 3)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();
        new Thread(()->{
            int value = atomicInteger.get();
            log.debug("Thread2 read value: " + value);
            // Thread2通過CAS修改value值為2
            if (atomicInteger.compareAndSet(value, 2)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = atomicInteger.get();
                log.debug("Thread2 read value: " + value);
                // Thread2通過CAS修改value值為1
                if (atomicInteger.compareAndSet(value, 1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 read value: 1
Thread2 read value: 1
Thread2 update from 1 to 2
Thread2 read value: 2
Thread2 update from 2 to 1
Thread1 update from 1 to 3

Thread1以為值沒有更新過，還是將1更新為了3

解決：

數(shù)據(jù)庫有個鎖稱為樂觀鎖，是一種基于數(shù)據(jù)版本實現(xiàn)數(shù)據(jù)同步的機制，每次修改一次數(shù)據(jù)，版本就會進行累加。同樣，Java也提供了相應(yīng)的原子引用類AtomicStampedReference。

public class AtomicStampedReference<V> {
    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);
        }
    }
    ...

stamp是版本，每次修改可以通過+1保證版本唯一性。這樣就可以保證每次修改后的版本也會往上遞增。

public class AtomicStampedReferenceTest {
    public static void main(String[] args) {
        // 定義AtomicStampedReference    Pair.reference值為1, Pair.stamp為1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1,1);
        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread1 read value: " + value + ", stamp: " + stamp);
            // 阻塞1s
            LockSupport.parkNanos(1000000000L);
            // Thread1通過CAS修改value值為3   stamp是版本，每次修改可以通過+1保證版本唯一性
            if (atomicStampedReference.compareAndSet(value, 3,stamp,stamp+1)) {
                log.debug("Thread1 update from " + value + " to 3");
            } else {
                log.debug("Thread1 update fail!");
            }
        },"Thread1").start();
        new Thread(()->{
            int[] stampHolder = new int[1];
            int value = (int)atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
            // Thread2通過CAS修改value值為2
            if (atomicStampedReference.compareAndSet(value, 2,stamp,stamp+1)) {
                log.debug("Thread2 update from " + value + " to 2");
                // do something
                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                log.debug("Thread2 read value: " + value+ ", stamp: " + stamp);
                // Thread2通過CAS修改value值為1
                if (atomicStampedReference.compareAndSet(value, 1,stamp,stamp+1)) {
                    log.debug("Thread2 update from " + value + " to 1");
                }
            }
        },"Thread2").start();
    }
}

Thread1 read value: 1, stamp: 1
Thread2 read value: 1, stamp: 1
Thread2 update from 1 to 2
Thread2 read value: 2, stamp: 2
Thread2 update from 2 to 1
Thread1 update fail!

因為版本不一樣，Thread1沒有將值修改成功，這就解決了ABA問題。

到此這篇關(guān)于Java CAS原子操作詳解的文章就介紹到這了,更多相關(guān)Java CAS內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: