10.原子变量

原子变量

原子变量是并发包中的一个并发安全工具，相较于普通变量，它提供了与volatile相同的可见性，相较于volatile变量，它又有对于复合操作的原子性（API中的复合操作）。它是一个实用的并发工具。

原子变量相当于一种泛化的volatile变量，能够支持原子的和有条件的读改写操作。它的原子性不是由锁来提供，而是基于硬件支持的CAS指令。如AtomicInteger表示一个int型值，并提供了set和get方法，这与volatile类型的int变量在读取和写入有着同样的内存语义。

java.util.concurrent包提供了12个原子变量类，分为四类：

• 标量类
• 更新器类
• 数组类
• 复合变量类

最常用的是标量类：AtomicInteger、AtomicLong、AtomICBool饿啊以及AtomicReference。所有这些类都支持CAS，此外AtomicInteger和AtomicLong还提供算术运算。

原子数组类（只支持Integer、Long和Reference版本）中的元素可以实现原子更新。原子数组类为数据的元素提供了volatile类型的访问语义，这是与普通数组不同的地方。

原子变量类是可变类，没有重写hashCode和equals方法，每个示例都是不同的。与其他可变对象相同，他们也不适合做基于散列的容器中的键值。

看一下AtomicInteger的部分源码，了解一下它的实现原理：

package java.util.concurrent.atomic;
import java.util.function.IntUnaryOperator;
import java.util.function.IntBinaryOperator;
import sun.misc.Unsafe;

/**
 * @since 1.5
 * @author Doug Lea
*/
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    // unsafe类提供了CAS的调用接口，这是原子类的核心基础
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    // 可以发现，内部存储int值的变量是volatile变量，所以说提供了volatile的语义
    private volatile int value;

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

 
    public AtomicInteger() {
    }

  
    public final int get() {
        return value;
    }

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

 
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

 // 这是个复合操作，使用的是Unsafe类，底层使用的就是CAS
    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 boolean weakCompareAndSet(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 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;
    }

   
    public String toString() {
        return Integer.toString(get());
    }

     
    public int intValue() {
        return get();
    }

    
    public long longValue() {
        return (long)get();
    }

     
    public float floatValue() {
        return (float)get();
    }

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

}

参考资料

[1] Java并发编程实战