JUC之Atomic源码解析

Atomic操作类型

1.基本类型

AtomicInteger

AtomicInteger使用的是volatile+cas的方式保证数据的操作原子性。这种方式是有缺点的，ABA问题是它的缺点，所以使用该类型，要能无视ABA带来的影响。没有深入到jvm的源码级别，这里说一下里面的几个特殊方法的说明：

public final int accumulateAndGet(int x,
                                      IntBinaryOperator accumulatorFunction) {
    	//IntBinaryOperator是个具体的累加过程，所以类是函数式编程声明
        int prev, next;
        do {
            prev = get();//获取当前值
            next = accumulatorFunction.applyAsInt(prev, x);//将x与当前值进行自定义累加计算
        } while (!compareAndSet(prev, next));//通过cas修改值
        return next;//返回修改后的值
}

public final int getAndAccumulate(int x,
                                      IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;//不同点在于他返回变更前的值
}

public final void lazySet(int newValue) {
    	//底层在设置value值时，只在写前面加了内存屏障storestore，后面是没有storeload屏障的
    	//相比于set方法，它更加轻量，但是由于没有storeload屏障，在后续的cas中会导致数据一致性问题
        unsafe.putOrderedInt(this, valueOffset, newValue);
}

AtomicBoolean

与AtomicInter类似，而且其底层的value值也是int类型的，所以就不过多赘述了。

AtomicLong

AtomicLong本身的cas操作依赖于机器性能支持，所以布尔类型的VM_SUPPORTS_LONG_CAS字段是确定该机器是否支持long的cas操作的，如果不支持，就只能采用加锁的方式来保证操作原子性了。除了这一点，其他与AtomicInteger都是一样的。

2.数组类型

AtomicIntegerArray

由于数组是集合形式的数据结构，所以不能整体的使用volatile+cas的方式保证原子性，而是在每个元素上使用volatile+cas保证原子性。

public class AtomicIntegerArray implements java.io.Serializable {
    private static final long serialVersionUID = 2862133569453604235L;

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //获取数组的起始偏移量
    private static final int base = unsafe.arrayBaseOffset(int[].class);
    private static final int shift;
    private final int[] array;//存放数据的数组，不用volatile修饰

    static {
        //获取元素的大小int是4个字节
        int scale = unsafe.arrayIndexScale(int[].class);
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
        shift = 31 - Integer.numberOfLeadingZeros(scale);
        //这是一个计算变量，Integer.numberOfLeadingZeros是看二进制前面的0的位数，4的二进制是100，所以前有29位0
    	//shift = 2
    }

    private long checkedByteOffset(int i) {
        if (i < 0 || i >= array.length)
            throw new IndexOutOfBoundsException("index " + i);
		//返回索引i的元素的起始偏移量
        return byteOffset(i);
    }

    private static long byteOffset(int i) {
        //offset(i) = shift*2^i 这是i元素的起始偏移量的计算公式
        return ((long) i << shift) + base;
    }
    
    public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //根据偏移量将元素变成volatile的，这样就保证了元素在线程间的可见性
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
    }
}

AtomicIntegerArray的核心是每个元素的地址计算+volatile+cas，这三者为原子性操作发挥了重要作用。

AtomicLongArray

与AtomicIntegerArray类似，区别就是底层可能是用lock保证原子性，而不是cas操作

AtomicReferenceArray

引用类型数组与上面的类似，不同的是比较使用的是unsafe.compareAndSwapObject方法，这个方法比较的是两个Object的地址值，当地址不一样，是不会成功的。

3.引用类型

AtomicReference</