JUC源码解析之一---AtomicInteger类源码解析

AtomicInteger类是JUC子包atomic包下的一个类，应该也算是该原子包下使用最多的一个类了。它基于CAS提供了一套原子更新一个整数的方法，对于i++操作，就不是一个原子操作，在并发的情况下会出现数据安全的问题。AtomicInteger类对这些操作进行 了很好的封装，并且也非常的高效。

下面我们就开始来分析其底层实现是什么样子的：

和以前一样，我们先看构造方法和成员变量：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));  // 使用unsafe获取到value属性在对象中的偏移量
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;  // 唯一实例变量

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    public AtomicInteger() {
    }

}

从继承体系上来看，AtomicInteger继承自Number抽象类，那我们就看看Number类的定义吧：

public abstract class Number implements java.io.Serializable {
    public abstract int intValue();
    public abstract long longValue();
    public abstract float floatValue();
    public abstract double doubleValue();
    public byte byteValue() {
        return (byte)intValue();
    }
    public short shortValue() {
        return (short)intValue();
    }
}

非常的简单，就是定义了基本类型值的获取。

从上面我们可以看到AtomicInteger类只有一个实例变量：value，在静态构造块中，使用unsafe类获取到value在对象中的偏离量，我们在介绍Unsafe类时都已经分析了具体的使用方法了。

下面我们再来看有那些实用的方法：

    public final int get() {  // 返回值
        return value;
    }
    public final void set(int newValue) {  // 设置值
        value = newValue;
    }
    public final int getAndSet(int newValue) {  // 利用CAS设置新值，返回旧值
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
    public final boolean compareAndSet(int expect, int update) {  // CAS的一层包装
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    public final int getAndIncrement() {  // 加一，返回旧值，类似于i++
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    public final int getAndDecrement() {  // 类似于 i--
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }
    public final int getAndAdd(int delta) {  // 加delta 返回旧值
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    public final int incrementAndGet() {  // 类似于++i
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    public final int decrementAndGet() {  // 类似于--i
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
    public final int addAndGet(int delta) {  // 加delta, 返回相加后的值
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }
    // 下面四个方法是JDK8新加的，IntUnaryOperator IntBinaryOperator 都是函数式接口，我们可以传入Lambda表达式，来实现更加复杂的逻辑。
    // 比如：atomicInteger.getAndUpdate((x) -> x * 2); 表示将value变为原来的两倍
    public final int getAndUpdate(IntUnaryOperator updateFunction) {  // CAS 更新值，放回旧值
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }
    public final int updateAndGet(IntUnaryOperator updateFunction) {  // CAS 更新值，放回新值
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }
    public final int getAndAccumulate(int x,
                                      IntBinaryOperator accumulatorFunction) {  // CAS 更新值，放回旧值
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }
    //atomicInteger.accumulateAndGet(3, (prev, x) -> prev - x); 表示将value-3
    public final int accumulateAndGet(int x,
                                      IntBinaryOperator accumulatorFunction) {  // CAS 更新值，放回新值
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }
    public int intValue() {
        return get();
    }
    public long longValue() {
        return (long)get();
    }
    public float floatValue() {
        return (float)get();
    }
    public double doubleValue() {
        return (double)get();
    }

好了，到这里AtomicInteger类的源码就分析结束了，我们发现，AtomicInteger类的源码还是必将简单的，最主要的核心思想就是CAS，明白了CAS自己也可以写一个AtomicInteger类出来，我们下一篇再见。