Java中cas實現原理

java提供了三個CAS操作不安全:

compareAndSwapLong compareAndSwapObject compareAndSwapInt () () ()

//Parameter meaning: object, attribute memory offset, attribute expected value, attribute update value
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);

抵消:對象在內存中包含對象頭和對象實例數據,和對象頭占8個字節。對于64位的操作系統,壓縮指針占4個字節,所以我們通常說的對象頭占12個字節;例如,測試對象,x的偏置是頭的對象,也就是說,12個字節,和y的抵消是16

cas操作修改測試類的變量x。

public class CASTest {
    public static void main(String[] args) {
        Test test = new Test();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long xOffset = UnsafeFactory.getFieldOffset(unsafe, Test.class, "x");
        System.out.println(xOffset); //12
        long yOffset = UnsafeFactory.getFieldOffset(unsafe, Test.class, "y");
        System.out.println(yOffset); //16
        unsafe.compareAndSwapInt(test, xOffset, 0, 1);
        System.out.println(test.x);
    }    
    static class Test {
        int x;
        int y;
    }
}

能保證原子性,但不能保證秩序和可見性。因此,一般來說,可以用于揮發性,以確保線程安全。底層最后執行CAS指令(原子操作修改變量值)和比較期望值與實際值在內存中。如果比較結果相等,返回舊值(期望值),表明CAS操作成功。如果他們是不平等的,在內存返回實際值,表明CAS操作失敗。

CAS實現線程安全的操作

public class CASTest {
    private static int sum = 0;
    private static CASLock casLock = new CASLock();
    public static void main(String[] args) throws InterruptedException {
        for (int i=0; i<10; i++) {
            new Thread(() -> {
                for (;;) {
                    if (casLock.getState() == 0 && casLock.cas()) {
                        try {
                            for (int j = 0; j < 10000; j++) {
                                sum++;
                            }
                        } finally {
                            casLock.setState(0);
                        }
                        break;
                    }
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(sum);
    }
}

public class CASLock {
    private volatile int state = 0;
    private static final Unsafe UNSAFE;
    private static final long OFFSET;
    static {
        UNSAFE = UnsafeFactory.getUnsafe();
        OFFSET = UnsafeFactory.getFieldOffset(UNSAFE, CASLock.class, "state");
    }    
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
    }
    public boolean cas() {
        return UNSAFE.compareAndSwapInt(this, OFFSET, 0, 1);
    }
}

原子在jdk類juc下包通過cas是線程安全的。

LongAdder和DoubleAdder原則

在高并發性下,CAS操作將有大量的線程旋轉,導致浪費線程資源。為了提高執行效率,V值分為多個變量。多個線程執行CAS操作同時在自己的變量。所有線程完成后執行,所有變量都是積累和統計。它的想法是類似于統計jdk8 ConcurrentHashMap的元素的數量。LongAdder DoubleAdder也實現這個想法。LongAdder定義了基本變量和單元數組變量,初始化并積累單元陣列通過散列,最后積累基礎和單元陣列的所有數字的結果。

以上就是關于“Java中cas實現原理”的介紹， 大家如果想了解更多相關知識，不妨來關注一下動力節點的Java在線學習，里面的課程內容從入門到精通，細致全面，適合沒有基礎的小伙伴學習，希望對大家能夠有所幫助。