AtomicXXX系列类使用分析

---

本博客系列是学习并发编程过程中的记录总结。由于文章比较多，写的时间也比较散，所以我整理了个目录贴（传送门），方便查阅。

并发编程系列博客传送门

---

在java.util.concurrent.atomic中，普通的原子类型有以下四种：

• AtomicBoolean：提供对基本数据类型boolean的原子性更新操作。
• AtomicInteger：提供对基本数据类型int的原子性更新操作。
• AtomicLong：提供对基本数据类型long的原子性更新操作。
• AtomicReference：这是一个泛型类，提供对引用类型的原子性更新操作。

数组相关的操作类有：

• AtomicLongArray：提供对int[]数组元素的原子性更新操作。
• AtomicIntegerArray：提供对long[]数组元素的原子性更新操作。
• AtomicReferenceArray：提供对引用类型[]数组元素的原子性更新操作。

由于上面的原子操作类的实现原理差不多，我们这边就选择AtomicInteger来分析。

代码分析#

构造函数#

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    //Unsafe类提供底层的CAS机制 
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //valueOffset是value值的内存地址值偏移值，这个值的作用是获取value在主内存中的值
    private static final long valueOffset;
    //类加载的时候获取valueOffset的值
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    //AtomicInteger具体的值存放在这个变量中，
    //这个变量使用volatile修饰，具有可见性
    private volatile int value;
    
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    //默认为0
    public AtomicInteger() {
    }
}

get和set方法分析#

//value使用volatile修饰，每次能拿到最新值
public final int get() {
    return value;
}

//value使用volatile修饰,赋值操作具有原子性,所以这个操作也是线程安全的
//这个方法和compareAndSet方法的区别是：compareAndSet方法会判断预期值和当前值，而set方法不会做任何判断，直接更新
// set方法不会在意原始值是多少，而compareAndSet会确保主内存中的值和预期值相等才更新。
public final void set(int newValue) {
    value = newValue;
}

//这个方法可能比较令人疑惑，我查了下unsafe的putOrderedInt方法,如下

/**  Sets the value of the integer field at the specified offset in the
  * supplied object to the given value. This is an ordered or lazy
  * version of <code>putIntVolatile(Object,long,int)</code>, which
  * doesn't guarantee the immediate visibility of the change to other
  * threads. It is only really useful where the integer field is
  * <code>volatile</code>, and is thus expected to change unexpectedly.
  */
上面的意思大致是：putOrderedInt方法不保证可见性，只有在变量是volatile修饰时才有用，
我们这边的value变量就是用volatile修饰的，所以我认为AtomicInteger的`set`方法和`lazySet`方法
功能是一致的。
public final void lazySet(int newValue) {
    unsafe.putOrderedInt(this, valueOffset, newValue);
}

//将value设置成给定值，并返回旧值
public final int getAndSet(int newValue) {
    return unsafe.getAndSetInt(this, valueOffset, newValue);
}
//使用CAS机制更新
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
//使用CAS机制更新
public final boolean weakCompareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
//CAS加1，并且返回原始值
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
//CAS减1，并且返回原始值
public final int getAndDecrement() {
    return unsafe.getAndAddInt(this, valueOffset, -1);
}
//CAS加减delta值，并且返回原始值
public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}
//CAS加1，并且返回最新值
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
//CAS减1，并且返回最新值
public final int decrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
//CAS加减delta值，并且返回最新值
public final int addAndGet(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

策略更新#

下面几个方法个人觉得不是很有用，和上面的区别就是更新的值不是穿进去的，而是通过IntUnaryOperator和IntBinaryOperator接口算出来的。

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;
}

简单总结#

总体来说，AtomicBoolean、AtomicInteger、AtomicLong和AtomicReference原理比较简单：使用CAS保证原子性，使用volatile保证可见性，最终能保证共享变量操作的线程安全。

AtomicLongArray、AtomicIntArray和AtomicReferenceArray的实现原理略有不同，是用CAS机制配合final机制来实现共享变量操作的线程安全的。感兴趣的同学可以自己分析下，也是比较简单的。