Java中cas的實現原理是什么

這篇文章主要介紹了Java中cas的實現原理是什么的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Java中cas的實現原理是什么文章都會有所收獲，下面我們一起來看看吧。

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

compareAndSwapLong compareAndSwapObject compareAndSwapInt () () ()

//Parameter meaning: object, attribute memory offset, attribute expected value, attribute update valuepublic 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中cas的實現原理是什么”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。