AtomicInteger源碼學習筆記

package java.util.concurrent.atomic;
import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;
import sun.misc.Unsafe;

/**

更新Int型的值可能是原子操作，

併發包中詳細描述了原子值的性質。

AtomicInteger被使用在原子性的增長計數這樣的應用上，但是它並不能當做Integer去使用；然而，這個類繼承了Number，也就是說它允許統一的使用Number類中的工具和作爲數據基本操作類
public class AtomicIntegerextends Number implementsjava.io.Serializable {
    private static final long serialVersionUID= 6214790243416807050L;
    //需要使用到Unsafe中的CompareAndSweep 對數據進行操作 

private static final Unsafeunsafe = Unsafe.getUnsafe();
   //位移偏量

 private static final long valueOffset;
    static {
        try {

//得到AtomicInteger中的value屬性，通過unsafe.objectFiledOffset方法獲得此屬性的偏移量；

//因爲類是動態加載的，而你實現不能知道這個類加載後的內存位置，爲了可以找到value，先記錄value在此對象的內存偏量，再根據對象和內存偏量得到這個屬性；
            valueOffset =unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {throw new Error(ex); }
    }

爲了保證線程可見，使用volatile關鍵字聲明value變量
    private volatile int value;

    /**

通過給一個初始值的方式初始化AtomicInteger
     */
    publicAtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**

以0初始化AtomicInteger
     * Creates a new AtomicInteger with initial value {@code0}.
     */
    publicAtomicInteger() {
    }

    /**
     *得到最新的值，並返回
     * @returnthe current value
     */
    public final intget() {
        return value;
    }

    /**

設置爲定值
     * Sets to the given value
     * @paramnewValue the new value
     */
    public final voidset(int newValue) {
        value = newValue;
    }

    /**
     * Eventually sets to the given value.

設定最終給定的值？？不太理解， 讓我們看看unsafe中的putOrderedInt這個native方法的意思

public native void putOrderedInt(Object obj, long offset, int value);
==>設置obj對象中offset偏移地址對應的整型field的值爲指定值。這是一個有序或者有延遲的putIntVolatile方法，並且不保證值的改變被其他線程立即看到。只有在field被<code>volatile</code>修飾並且期望被意外修改的時候使用纔有用。
==>obj:  包含要修改field的對象 
==>offset:    <code>obj</code>中整型field的偏移量
==>value:   field將被設置的新值
     */
    public final voidlazySet(int newValue) {
        unsafe.putOrderedInt(this,valueOffset, newValue);
    }

    /**
     * Atomically sets to the given value and returns the old value.
     *原子性的把 給入的值set 並返回就得值
     */
    public final intgetAndSet(int newValue) {
        return unsafe.getAndSetInt(this,valueOffset, newValue);
    }

/**
讓我們看一下unsafe.getAndSetInt

public final int getAndSetInt(Object obj, longvalueOffset, intnewValue) {
    int oldvalue;
    do {
        oldvalue= this.getIntVolatile(obj,valueOffset);
    } while(!this.compareAndSwapInt(obj,valueOffset,oldvalue,newValue));
    return oldvalue;
}

很明顯，我們根據對象和屬性的偏移量，即可獲得AtomicInterger中的value的值，我們根據這個值可以得到現在這個線程的線程棧中得到的這個value，根據這個value和內存地址上的值進行比對，如果一樣說明這個值沒有被改變，可以進行swap操作，循環退出。否則繼續循環

*/
    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code==} the expected value.
     * 如果最新的值和期待的相等，則原子性的根據給定的值進行update操作，此方法與上一個方法幾乎相似，都是直接或間接調用了unsafe的compareAndSwapInt方法，不同是，getAndSet是隻給定一個新值，由unsafe中的getAndSetInt方法根據對象和內存偏量取得AtomicInteger中的value值；生成一個臨時變量，然後再調用compareAndSwapInt進行比對和交換；

而此方法compareAndSet是給定期望值和新值，由compareAndSwapInt去獲得tomicInteger中的value值和期望值進行比較；

     * @paramexpect the expected value
     * @paramupdate the new value
     * @return{@codetrue} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final booleancompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this,valueOffset, expect, update);
    }

    /**

同上方法；不知道有什麼區別
     */
    public final booleanweakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this,valueOffset, expect, update);
    }

    /**
     * Atomically increments by one the current value.
     *根據current value原子性的增長，比如初始值爲50 則從50開始

     * @returnthe previous value
     */
    public final intgetAndIncrement() {
        return unsafe.getAndAddInt(this,valueOffset,1);
    }

    /**
     * Atomically decrements by one the current value.
     *根據current value原子性的遞減 比如初始值爲50 則從50開始
     * @returnthe previous value
     */
    public final intgetAndDecrement() {
        return unsafe.getAndAddInt(this,valueOffset, -1);
    }

    /**
     * Atomically adds the given value to the current value.
     *給據給定的值原型性的增加
     * @paramdelta the value to add
     * @returnthe previous value
     */
    public final intgetAndAdd(int delta) {
        return unsafe.getAndAddInt(this,valueOffset, delta);
    }

    /**
     * Atomically increments by one the current value

同getAndIncrement方法，但是此方法如果初始值爲50，增加50此；則會從51加到100
     * @returnthe updated value
     */
    public final intincrementAndGet() {
        return unsafe.getAndAddInt(this,valueOffset,1) + 1;
    }

    /**
     * Atomically decrements by one the current value.
     *同getAndDecrement方法，但是此方法如果初始值爲50，會從49起開始遞減
     * @returnthe updated value
     */
    public final intdecrementAndGet() {
        return unsafe.getAndAddInt(this,valueOffset, -1) -1;
    }

    /**
     * Atomically adds the given value to the current value.
     *同……
     * @paramdelta the value to add
     * @returnthe updated value
     */
    public final intaddAndGet(int delta) {
        return unsafe.getAndAddInt(this,valueOffset, delta) + delta;
    }
}