Java學習筆記:atomic的實現原理?

在多線程的場景中,我們需要保證數據安全,就會考慮同步的方案,通常會使用synchronized或者lock來處理,使用了synchronized意味著內核態的一次切換。這是一個很重的操作。

有沒有一種方式,可以比較便利的實現一些簡單的數據同步,比如計數器等等。concurrent包下的atomic提供我們這么一種輕量級的數據同步的選擇。

class MyThread implements Runnable {
 
    static AtomicInteger ai=new AtomicInteger(0);
 
    public void run() {
        for (int m = 0; m < 1000000; m++) {
            ai.getAndIncrement();
        }
    }
};
 
public class TestAtomicInteger {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt = new MyThread();
 
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        t1.start();
        t2.start();
        Thread.sleep(500);
        System.out.println(MyThread.ai.get());
    }
}

在以上代碼中,使用AtomicInteger聲明了一個全局變量,并且在多線程中進行自增,代碼中并沒有進行顯示的加鎖。以上代碼的輸出結果,永遠都是2000000。如果將AtomicInteger換成Integer,打印結果基本都是小于2000000。
也就說明AtomicInteger聲明的變量,在多線程場景中的自增操作是可以保證線程安全的。接下來我們分析下其原理。

原理:
這里,我們來看看AtomicInteger是如何使用非阻塞算法來實現并發控制的。
AtomicInteger的關鍵域只有一下3個:

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
 
    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
 
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
 
    private volatile int value;
 
    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
 
    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }
 
    ......
}

這里, unsafe是java提供的獲得對對象內存地址訪問的類,注釋已經清楚的寫出了,它的作用就是在更新操作時提供“比較并替換”的作用。實際上就是AtomicInteger中的一個工具。
valueOffset是用來記錄value本身在內存的編譯地址的,這個記錄,也主要是為了在更新操作在內存中找到value的位置,方便比較。

value是用來存儲整數的時間變量,這里被聲明為volatile。volatile只能保證這個變量的可見性。不能保證他的原子性。

可以看看getAndIncrement這個類似i++的函數,可以發現,是調用了UnSafe中的getAndAddInt。

    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
 
    /**
     * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
 
    public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
            //使用unsafe的native方法,實現高效的硬件級別CAS
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));
 
        return var5;
    }

如何保證原子性:自旋 + CAS(樂觀鎖)。在這個過程中,通過compareAndSwapInt比較更新value值,如果更新失敗,重新獲取舊值,然后更新。

優缺點:
CAS相對于其他鎖,不會進行內核態操作,有著一些性能的提升。但同時引入自旋,當鎖競爭較大的時候,自旋次數會增多。cpu資源會消耗很高。

換句話說,CAS+自旋適合使用在低并發有同步數據的應用場景。

Java 8做出的改進和努力
在Java 8中引入了4個新的計數器類型,LongAdder、LongAccumulator、DoubleAdder、DoubleAccumulator。他們都是繼承于Striped64。

在LongAdder 與AtomicLong有什么區別?
Atomic*遇到的問題是,只能運用于低并發場景。因此LongAddr在這基礎上引入了分段鎖的概念。可以參考《JDK8系列之LongAdder解析》一起看看做了什么。

大概就是當競爭不激烈的時候,所有線程都是通過CAS對同一個變量(Base)進行修改,當競爭激烈的時候,會將根據當前線程哈希到對于Cell上進行修改(多段鎖)。

    /**
     * Table of cells. When non-null, size is a power of 2.
     */
    transient volatile Cell[] cells;
 
    /**
     * Base value, used mainly when there is no contention, but also as
     * a fallback during table initialization races. Updated via CAS.
     */
    transient volatile long base;
    /**
     * Padded variant of AtomicLong supporting only raw accesses plus CAS.
     *
     * JVM intrinsics note: It would be possible to use a release-only
     * form of CAS here, if it were provided.
     */
    @sun.misc.Contended static final class Cell {
        volatile long value;
        Cell(long x) { value = x; }
        final boolean cas(long cmp, long val) {
            return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
        }
 
        // Unsafe mechanics
        private static final sun.misc.Unsafe UNSAFE;
        private static final long valueOffset;
        static {
            try {
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> ak = Cell.class;
                valueOffset = UNSAFE.objectFieldOffset
                    (ak.getDeclaredField("value"));
            } catch (Exception e) {
                throw new Error(e);
            }
        }
    }

可以看到大概實現原理是:通過CAS樂觀鎖保證原子性,通過自旋保證當次修改的最終修改成功,通過降低鎖粒度(多段鎖)增加并發性能。

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。