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;
    }
}