Java原子类之AtomicInteger源码分析

简介

AtomicInteger是Java并发包下提供的原子整数类，主要操作的是int类型的整数，底层是通过调用Unsafe的CAS，volatile关键字，自选锁思想等方法多线程情况下实现原子操作，保证安全性。

继承结构

继承Number抽象类，使得其有转换其他类型的方法。

原子操作

原子操作是指不会被线程调度机制打断的操作，这种操作一旦开始，就一直运行到结束，中间不会有任何线程上下文切换。

原子操作可以是一个步骤，也可以是多个步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分，将整个操作视作一个整体是原子性的核心特征。

源码分析

 主要属性

    //序列化号
    private static final long serialVersionUID = 6214790243416807050L;

    //通过Unsafe类获取Unsafe的实例
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    
    //标识value字段的偏移量
    private static final long valueOffset;

    //静态代码块  通过unsafe获取value字段的内存偏移量
    static {
        try {
            //objectFieldOffset()方法是native方法 
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //存储int类型值的属性
    private volatile int value;

1.使用int类型的value存储值，且使用volatile修饰，volatile主要是保证可见性，即一个线程修改value值对另外一个线程是可见的，主要的实现原理是内存屏障(加了lock前缀指令）

2.调用Unsafe的objectFieldOffset()方法获取value字段在类中的偏移量，用于后面的CAS操作使用

构造方法

    //初始化value值的构造方法
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    //空参构造方法
    public AtomicInteger() {
    }

get（）set(int newValue)方法

    //获取当前的value值
    public final int get() {
        return value;
    }
    //将value值设定为newValue
    public final void set(int newValue) {
        value = newValue;
    }

getAndSet（int newValue）方法

    //原子的设置为给定值并返回旧值
    public final int getAndSet(int newValue) {
        //this为当前对象  valueOffset为value值在内存中的偏移量
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

Unsafe中的getAndSetInt（Object var1,long var2,int var4）方法

    public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //获取主内存中当前value的值
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
    }

这个方法的三个参数为：

1.操作的对象

2.对象中value字段的偏移量

3.要修改的值

        可以看到，这里通过调用compareAndSwapInt()方法实现，这是一个native方法，在下面我们会介绍这个方法。这里使用了自旋的思想，通过获取内存中当前value的值，通过CAS操作将value值修改为var4。为什么要使用自旋的思想呢？我的理解是为了避免线程间的上下文切换，这也是耗费资源的操作，通过一定的自旋，避免的线程的上下文切换，一定情况下提高了效率。

compareAndSet(int expect,int update)方法

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

这里也是调用的Unsafe.compareAndSwapInt()方法实现，这个方法的四个参数含义：

    1.操作的对象

    2.对象中字段的偏移量

    3.原来的值，即期望值

    4.要修改的值

这是一个native方法，底层是用C/C++写的，主要是调用CPU的CAS指令来实现，它能够保证只有当对应偏移量处的字段值是期望值时才会更新，即类似下面的操作：

if(value == expect){
    value = newValue;
}

 通过CPU的CAS指令可以保证这两步操作是一个整体，也就不会出现多线程环境中可能比较的时候value值是a,而另外一个线程真正要赋值的时候value值可能已经变成b了的问题。

getAndIncrement()方法

这个方法是将value值加1，底层通过CAS操作保证安全

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //Unsafe中的方法
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

getAndIncrement()方法底层是调用Unsafe的getAndAddInt()方法，这个方法有三个参数：

    1.操作的对象

    2.对象中字段的偏移量

    3.要增加的值

查看Unsafe的getAndAddInt()方法的源码，可以看到它是先获取当前对象的值，然后再调用compareAndSwapInt()尝试更新对象偏移量处的值，如果成功了即跳出循环，如果不成功就再重新获取值，尝试更新值，直到成功为止，这就是（CAS+自旋）的乐观锁机制。

AtomicInteger中其他方法几乎都是类似的调用Unsafe的compareAndSwapInt()来保证对value值更新的原子性。

getAndDecrement()方法

这个方法是将value值减1，底层通过CAS操作保证安全

    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

    //Unsafe中的方法
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

和上面分析的一样，这里将其他的源码放在下面

    //获取并加指定的值  
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    //返回添加1后的值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    //返回减1后的值
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
    //返回添加指定的值后的值
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        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 int accumulateAndGet(int x,
                                      IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }
    //toString方法
    public String toString() {
        return Integer.toString(get());
    }
    //获取当前value值  以下的这些方法是继承Number抽象类要实现的抽象方法
    public int intValue() {
        return get();
    }
    //转换为long类型的值  
    public long longValue() {
        return (long)get();
    }
    //转换为float类型的值
    public float floatValue() {
        return (float)get();
    }

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

总结

AtomicInteger中维护了一个使用volatile修饰的变量value，保证了多线程操作下的可见性

AtomicInteger中的主要方法几乎都调用了Unsafe的compareAndSwapInt()方法保证对变量修改的原子性。

缺点：会引起ABA问题，CAS操作一般都会引起这种问题，可以使用原子引用或者原子时间戳引用，下一节继续分析。以上纯属于个人理解，有错误的地方还请大家指正。加油！！