【JAVA并发】AtomicInteger源码注释

AtomicInteger源码

在java.util.concurrent.atomic包下提供了大量的原子类，这里以AtomicInteger源码为例，添加了一些注释，个人理解，供参考；

其中比较重要的一个概念是CAS操作，现代CPU已广泛支持，在JDK的AtomicInteger类中是调用了Unsafe类的compareAndSwapInt方法实现的，代码(jdk1.7.0_79)如下：

package java.util.concurrent.atomic;
import sun.misc.Unsafe;


public class AtomicInteger extends Number implements java.io.Serializable {
    //序列化相关
    private static final long serialVersionUID = 6214790243416807050L;

    // JDK里使用的一个工具类对象，提供一些不安全的操作的方法，一般不会在自己的程序中使用该类
    //在这里主要用到其中的objectFieldOffset、putOrderedInt、compareAndSwapInt方法
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    
    //value成员属性的内存地址相对于对象内存地址的偏移量
    private static final long valueOffset;

    static {
      try {
        //初始化valueOffset，通过unsafe.objectFieldOffset方法获取成员属性value内存地址相对于对象内存地址的偏移量
        valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
    }
    //int的值，设为volatile，保证线程之间的可见性
    private volatile int value;

    /**
     * 构造方法，传入指定int值
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * 构造方法，使用默认值0
     */
    public AtomicInteger() {
    }

    /**
     * 获取int值
     */
    public final int get() {
        return value;
    }

    /**
     * 设为指定值
     */
    public final void set(int newValue) {
        value = newValue;
    }

    /**
     * 最终设为指定值，但其它线程不能马上看到变化，会延时一会
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

    /**
     * 以原子方式设置为给定值，并返回旧值
     */
    public final int getAndSet(int newValue) {
        //乐观锁，非阻塞同步方式，循环调用compareAndSet，直到成功
        for (;;) {
            int current = get();
            //CAS操作，期待值current与内存中的值比较，相等的话设为newValue值
            //否则下个循环，调用get()获取current值，继续执行CAS操作直到成功
            if (compareAndSet(current, newValue))
                return current;
        }
    }

    /**
     * CAS操作，现代CPU已广泛支持，是一种原子操作；
     * 简单地说，当期待值expect与valueOffset地址处的值相等时，设置为update值
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * 查看源码，与compareAndSet方法一致，不解？？
     */
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * 原子操作，自增，返回旧值
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * 原子操作，自减，返回旧值
     */
    public final int getAndDecrement() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * 原子操作，加上一个数，返回旧值
     */
    public final int getAndAdd(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * 原子操作，自增，返回新值
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * 原子操作，自减，返回新值
     */
    public final int decrementAndGet() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * 原子操作，加上一个数，返回新值
     */
    public final int addAndGet(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return next;
        }
    }

    /**
     * Returns the String representation of the current value.
     * @return the String representation of the current value.
     */
    public String toString() {
        return Integer.toString(get());
    }


    public int intValue() {
        return get();
    }

    public long longValue() {
        return (long)get();
    }

    public float floatValue() {
        return (float)get();
    }

    public double doubleValue() {
        return (double)get();
    }

}