AtomicLongArray源码解析

一、前言

    AtomicLongArray和AtomicIntegerArray源码都是差不多的，区别就是数据类型不一样而已，一个是long类型一个是int类型，都是支持对底层数组变量的原子操作。

二、源码解析

继承了哪些类

    由上图可知AtomicLongArray只继承了一个Serializable接口，其他什么也没有继承。

变量说明

//序列化序号，用来对对象进行反序列化时的判断
private static final long serialVersionUID = -2308431214976778248L;
//unsafe常量，设置为使用Unsafe.compareAndSwapInt进行更新，方法中多处需要使用unsafe变量
private static final Unsafe unsafe = Unsafe.getUnsafe();
//获取数组中第一个元素的内存地址
private static final int base = unsafe.arrayBaseOffset(long[].class);
//shift:转变，在这里表示左移
private static final int shift;
//存放元素的数组
private final long[] array;

shift是如何获取的？

static {
    //获取数据中单个元素占用的字节数
    int scale = unsafe.arrayIndexScale(long[].class);
    //判断数据类型缩放是不是2的幂，比如scale为8那么scale & (scale - 1)为 1000 & 0111 == 0
    if ((scale & (scale - 1)) != 0)
        throw new Error("data type scale not a power of two");
    //numberOfLeadingZeros表示将scale变成二进制位的话最左边有多少个0
    //numberOfLeadingZeros(scale)则为00000000 00000000 00000000 00001000
    //shift = 31 - 28 = 3，即左移3位
    shift = 31 - Integer.numberOfLeadingZeros(scale);
}

构造方法

    AtomicLongArray类的构造方法有两个，一个是自己根据参数length来new一个长度为length的数组，另外一个根据传入的数组参数将此参数数组赋值给变量array。

//构造方法创建长度为length的数组，并且赋值给数组元素array
public AtomicLongArray(int length) {
    array = new long[length];
}

//将参数数组赋值给元素变量数组
public AtomicLongArray(long[] array) {
    // Visibility guaranteed by final field guarantees
    this.array = array.clone();
}

两个特殊的方法

//检查下标i是否越界，并且返回其在内存中从base开始的偏移量
private long checkedByteOffset(int i) {
    //检查数组下标是否越界
    if (i < 0 || i >= array.length)
        throw new IndexOutOfBoundsException("index " + i);
    return byteOffset(i);
}
    
//返回下标i在内存中从base开始数的内存地址偏移量
private static long byteOffset(int i) {
    //比如i为2，从上可知shift为3，则 i << shift就是2*8
    return ((long) i << shift) + base;
}

    AtomicLongArray中大多数方法获取元素都是靠checkedByteOffset(int i) 方法来进行获取的，而checkedByteOffset(int i)又是靠byteOffset(int i)来实现的。

其他方法

① get(int i)方法。

//获取下标为i的元素
public final long get(int i) {
    //checkedByteOffset(i)表示检查下标是否越界并且返回下标i的从base开始的内存地址
    //getRaw(offset)方法就是根据内存偏移量来获取指定内存地址的元素
    return getRaw(checkedByteOffset(i));
}
//根据内存地址的偏移量获取数组的元素
private long getRaw(long offset) {
    return unsafe.getLongVolatile(array, offset);
}

② set(int i, long newValue)方法。

//插入新的值到指定数组下标的位置
public final void set(int i, long newValue) {
    unsafe.putLongVolatile(array, checkedByteOffset(i), newValue);
}

③ getAndSet(int i, long newValue)方法。

//根据下标获取数组中的元素的值，并且将此数组的下标的值变为新值newValue
public final long getAndSet(int i, long newValue) {
    return unsafe.getAndSetLong(array, checkedByteOffset(i), newValue);
}

④ compareAndSet(int i, long expect, long update)方法。

//根据数组下标获取数组元素，然后和expect进行比较，若一样，就将其值替换为update
//就是CAS的原理
public final boolean compareAndSet(int i, long expect, long update) {
    return compareAndSetRaw(checkedByteOffset(i), expect, update);
}

//根据偏移量offset获取其内存地址的值，并且和expect进行比较，若相等就将其值替换为update
private boolean compareAndSetRaw(long offset, long expect, long update) {
    return unsafe.compareAndSwapLong(array, offset, expect, update);
}

⑤ getAndIncrement(int i)方法 和 getAndDecrement(int i)方法。

//先获取指定下标的值，然后再让此值加一，利用的是getAndAdd方法
public final long getAndIncrement(int i) {
    return getAndAdd(i, 1);
}
//先获取指定下标的值，然后再让此值减一，利用的是getAndAdd方法
public final long getAndDecrement(int i) {
    return getAndAdd(i, -1);
}

//获取指定下标的值，并且在指定下标的值的基础上加delta
public final long getAndAdd(int i, long delta) {
    return unsafe.getAndAddLong(array, checkedByteOffset(i), delta);
}

⑥ incrementAndGet(int i)方法 和 decrementAndGet(int i)方法。

//先对指定下标的值加一，然后返回加一后的值
public final long incrementAndGet(int i) {
    return getAndAdd(i, 1) + 1;
}

//先对指定下标的值减一，然后返回减一后的值
public final long decrementAndGet(int i) {
    return getAndAdd(i, -1) - 1;
}

⑦ addAndGet(int i, long delta)方法。

//先对指定下标的值加上指定数值delta，然后返回加后的值
public long addAndGet(int i, long delta) {
    return getAndAdd(i, delta) + delta;
}

⑧ toString()方法。

//toString方法是利用StringBuilder来进行处理的
public String toString() {
    //若数组为空，则length为0
    int iMax = array.length - 1;
    //若数组为空，则0 - 1 = -1就返回“[]”
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    //遍历数组元素，并且添加到StringBuilder中
    for (int i = 0; ; i++) {
        b.append(getRaw(byteOffset(i)));
        //条件判断，用来跳出此循环并且返回结果
        if (i == iMax)
            return b.append(']').toString();
        b.append(',').append(' ');
    }
}

三、总结

     AtomicLongArray和AtomicIntegerArray差不多，区别就是AtomicLongArray的shift左移3，而AtomicIntegerArray中shift左移2，以及数据类型一个为Integer另外一个为Long，然后其他的几乎没有什么区别。