Java AtomicInteger和AtomicStampedReference源码深度解析

基于JDK1.8详细介绍了JUC下面的AtomicInteger和AtomicStampedReference原子类源码和原理。

AtomicInteger用于实现通过原子的方式更新单个变量。AtomicInteger 中保存了一个核心字段value，它就代表了Atomiclnteger 的当前实际取值，所有的方法都是围绕该值进行的。

还有一个属性valueOffset，它保存着value 字段在Atomiclnteger 对象中的偏移量。Unsafe中的CAS方法都是通过字段的偏移量来操作字段的。

private volatile int value;


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


public AtomicInteger() {
}


private static final Unsafe unsafe = Unsafe.getUnsafe();

private static final long valueOffset;

static {
    try {
        //初始化value字段的偏移量
        valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) {
        throw new Error(ex);
    }
}

public final int get() {
    return value;
}


public final void set(int newValue) {
    value = newValue;
}


public final int getAndSet(int newValue) {
    return unsafe.getAndSetInt(this, valueOffset, newValue);
}



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


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



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



public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}



public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 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 void lazySet(int newValue) {
    unsafe.putOrderedInt(this, valueOffset, newValue);
}

可以看到，里面的方法都是调用的Unsafe类方法，进行的CAS操作。

Atomic包实际上只提供了3种基本类型的原子更新：int、long、boolean，其中boolean也是转换为int的0、1进行更新的，实际上并没有char、float和double等的CAS操作，实际上char、 float、double都可以转换为int或者long在进行操作，如果DoubleAdder就是采用Double.doubleToRawLongBits将double转换为long类型的值在进行操作。

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);


public final boolean compareAndSet(boolean expect, boolean update) {
    int e = expect ? 1 : 0;
    int u = update ? 1 : 0;
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

通过原子的方式更新单个变量的原子类的升级版，Atomic包提供了以下2个类：

1. AtomicMarkableReference< V >：维护带有标记位的对象引用，可以原子方式对其进行更新。
2. AtomicStampedReference< V >：维护带有整数标志的对象引用，可用原子方式对其进行更新。

上面两个原子类的方法以及原理几乎一致，属于带有版本号的原子类。我们知道CAS操作的三大问题之一就是“ABA”问题：CAS在操作值的时候，需要检查预期值有没有发生变化，如果没有发生变化则更新。但是，如果一个线程t1首先获取了预期值A，此时另一个线程t2则将值从A变成了B，随后又变成了A，随后t1再使用CAS进行比较交换的时候，会发现它的预期值“没有变化”，但实际上是变化过的。这就是ABA问题的由来。

ABA问题的解决思路就是使用版本号，1A->2B->3A，在Atomic包中，提供了一个现成的AtomicStampedReference类来解决ABA问题，使用的就是添加版本号的方法。还有一个AtomicMarkableReference实现类，它比AtomicStampedReference更加简单，AtomicStampedReference中每更新一次数据版本号也会更新一次，这样可以使用版本号统计到底更新了多少次，而AtomicMarkableReference仅仅使用了一个boolean值来表示值是否改变过，因此使用的比较少。

这里我们以AtomicStampedReference来讲解。

AtomicStampedReference内部不仅维护了我们的传递的对象reference，还维护了一个int类型的版本号stamp，它们都被存放到一个Pair类型的内部类实例中。当AtomicStampedReference 对应的数据被修改时，除了更新数据本身外，还必须要更新版本号，这个版本号一般都是自增的。当AtomicStampedReference 设置对象值时，对象值及版本号都必须满足期望值，才会更新成功。

private static class Pair {
    
    final T reference;
    
    final int stamp;

    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }

    
    static  Pair of(T reference, int stamp) {
        return new Pair(reference, stamp);
    }
}


private volatile Pair pair;


public AtomicStampedReference(V initialRef, int initialStamp) {
    //初始化一个Pair对象，并初始化属性值
    pair = Pair.of(initialRef, initialStamp);
}

最重要的就是compareAndSet方法，它需要传递：期望值、新值、期望版本号、新版本号，当期望值和期望版本号都与此时内部的真实值和真实版本号相等的时候，就会调用compareAndSwapObject使用一个新的Pair对象替换旧的Pair对象，同时完成reference和stamp的更新。

public boolean compareAndSet(V expectedReference,
                             V newReference,
                             int expectedStamp,
                             int newStamp) {
    Pair current = pair;
    //一系列的判断，如果两个预期值都相等，那么尝试调用compareAndSwapObject使用新的Pair对象替代旧的Pair对象
    //这样就同时完成了reference和stamp的更新
    return
            expectedReference == current.reference &&
                    expectedStamp == current.stamp &&
                    ((newReference == current.reference &&
                            newStamp == current.stamp) ||
                            casPair(current, Pair.of(newReference, newStamp)));
}


private boolean casPair(Pair cmp, Pair val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}



public V getReference() {
    return pair.reference;
}


public int getStamp() {
    return pair.stamp;
}



public void set(V newReference, int newStamp) {
    Pair current = pair;
    //如果新对象引用以及新版本号和之前的都一样那就不设置
    //否则就是新建一个Pair对象并设置相应的属性，替代原来的Pair对象
    if (newReference != current.reference || newStamp != current.stamp)
        this.pair = Pair.of(newReference, newStamp);
}

实际上，如果更新的数据是无状态的数据，那么使用基本的原子类也可以完成目的，即如果线程A将值从1->2->1，而线程B仅仅是使用了值，这是没什么问题的，但是如果和业务相关联，比较的对象是有状态的，那么可能会出现严重问题。

比如还是线程A将值从1->2->1，而线程B的业务逻辑是如果发现数据改变过，那么就不能操作，这样的话就不能单纯的比较值了，这就需要用到版本号了。

public class AtomicStampedReferenceDemo {

    public static void main(String args[]) {
        //初始值为0，版本号为0
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(0, 0);

        Thread thread = new Thread(() -> {
            //先获取标志位
            int timestamp = atomicStampedReference.getStamp();
            //获取原值
            int reference = atomicStampedReference.getReference();
            System.out.println("原值reference: " + reference);
            //阻塞，等待被唤醒
            LockSupport.park();
            if (atomicStampedReference.compareAndSet(reference, reference + 1, timestamp, timestamp + 1)) {
                System.out.println("更新成功，新值reference: " + atomicStampedReference.getReference());
            } else {
                System.out.println("更新失败，新值reference: " + atomicStampedReference.getReference());
                System.out.println("虽然原值和新值相等，但是是在线程阻塞过程中值发生了变化，变化了" + atomicStampedReference.getStamp() + "次");
            }
        });
        thread.start();


        Thread thread1 = new Thread(() -> {
            //对数据先加一再减一，反复4次，最终reference的值是不变的
            for (int i = 0; i < 4; i++) {
                int timestamp = atomicStampedReference.getStamp();
                int reference = atomicStampedReference.getReference();
                if (i % 2 == 0) {
                    atomicStampedReference.compareAndSet(reference, reference + 1, timestamp, timestamp + 1);
                } else {
                    atomicStampedReference.compareAndSet(reference, reference - 1, timestamp, timestamp + 1);
                }
            }
            //唤醒阻塞的thread线程
            LockSupport.unpark(thread);
        });
        thread1.start();
    }
}

同样的逻辑，使用普通原子类就能更新成功：

public class AtomicRefrenceDemo {

    public static void main(String args[]) {
        //初始值为0
        AtomicReference atomicReference = new AtomicReference(0);

        Thread thread = new Thread(() -> {
            int reference = atomicReference.get();
            System.out.println("原值reference: " + reference);
            //阻塞，等待被唤醒
            LockSupport.park();
            if (atomicReference.compareAndSet(reference, reference + 1)) {
                System.out.println("更新成功，新值reference: " + atomicReference.get());
            } else {
                System.out.println("更新失败，新值reference: " + atomicReference.get());
            }
        });
        thread.start();


        Thread thread1 = new Thread(() -> {
            //对数据先加一再减一，反复4次，最终的值是不变的
            for (int i = 0; i < 4; i++) {
                int reference = atomicReference.get();
                if (i % 2 == 0) {
                    atomicReference.compareAndSet(reference, reference + 1);
                } else {
                    atomicReference.compareAndSet(reference, reference - 1);
                }
            }
            //唤醒阻塞的thread线程
            LockSupport.unpark(thread);
        });
        thread1.start();
    }
}

AtomicInteger和AtomicStampedReference都可用于通过原子的方式更新单个变量。

AtomicInteger的操作存在CAS中的“ABA”问题，而AtomicStampedReference的出现则是为了解决这个问题而生的。

相关文章：

1. Unsafe：JUC—Unsafe类的原理详解与使用案例。
2. volatile：Java中的volatile实现原理深度解析以及应用。
3. CAS：Java中的CAS实现原理深度解析与应用案例。
4. 伪共享：Java中的伪共享深度解析以及避免方法。
5. JMH：Java使用JMH进行方法性能优化测试。

如果有什么不懂或者需要交流，可以留言。另外希望点赞、收藏、关注，我将不间断更新各种Java学习博客！