AtomicInteger

这个类是Automic包下的类，用于提供对应类型的原子操作

这个类提供了整形的原子更新，主要用于例如原子增长的计数器，但是不能作为java.lang.Integer的替代使用。虽然这个类不能作为替代使用，但是这个类继承了Number类，允许基于对数字机型处理的类或者应用进行统一的访问。

首先是一些基本的变量和初始化

    // 设置好Unsafe工具
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //元素偏移量
    private static final long valueOffset;
    //实际的变量承载
    private volatile int value;
    
    static {
        try {
            //初始化偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    //用给定的整形元素初始化一个AtomicInteger
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    
    //创建一个新的AtomicInteger，利用默认初始化值0
    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);
    }
    
    //读取并设置元素，原子性的设置这个元素，同事返回旧的元素
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
    
    //CAS操作，当当前元素和期望元素相等，设置元素。
    //如果成功返回true，
    //如果返回false说明实际元素和期待元素不相等。
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    
    //和上面的CAS操作一样，
    //区别在于虽然实现上是一样的，但是从接口层面不提供保证
    //也就意味着这个方法可能会出现虚假的失败，并且不能保证内存顺序
    //所以很少把这个作为CAS操作的替代
    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);
    }
    
    //原子操作给当前元素增加一，区别于上面的，这个方法返回的是更新后的元素
    //等同于前面的是i++,这个是++i
    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;
    }
    

下面是一些1.8后加入的读写方法

    //这个方法是1.8加入的，
    //作用是利用给定的函数执行结果原子性更新当前元素，返回之前的元素
    //注意这个函数必须是不能有“副作用的”，因为如果由于线程争用产生了失败
    //这个方法函数可能需要重新执行的
    //IntUnaryOperator是1.8中开始提供的函数式编程接口
    //具体内容放到对应的部分
    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;
    }
    
    //同样是1.8开始提供的一个方法
    //作用是把获取的当前元素和给定的元素利用给定的函数进行运算后，
    //将结果设置进去，然后返回之前的元素
    //跟上面的类似的，这个函数同样是要求没有副作用的
    //因为当发生线程争用的时候，如果失败了需要重新进行尝试，
    //这个时候或缺的当前元素作为第一个参数，给定元素作为第二个参数
    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;
    }

然后是一些一般性的方法

    //转换为String的方法
    public String toString() {
        return Integer.toString(get());
    }
    
    //直接读取返回int
    public int intValue() {
        return get();
    }

    //直接读取然后强转long返回
    public long longValue() {
        return (long)get();
    }
    
    //强转float
    public float floatValue() {
        return (float)get();
    }
    
    //强转double
    public double doubleValue() {
        return (double)get();
    }