AtomicInteger分析

AtomicInteger类提供对一个整型变量的原子性操作，保证多线程安全。

以下来看一下类的定义

类定义

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

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
        //valueOffset是变量value的内存偏移值，对这个内存可以进行CAS操作
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

//value变量存的是整型的值
    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }
    //...后面的不显示

AtomicInteger的核心是value以及valueOffset变量，再通过操作系统提供的CAS操作，可以对value这个变量进行原子性操作。

方法

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

/*
unsafe使用一个do while循环，先读出value值，再利用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 int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

总结

AtomicInteger的整型值存在AtomicInteger实例的value变量中，类初始化时就把value变量的内存偏移值算好，结合unsafe的CAS操作，支持对value的各种原子性操作。