源码阅读 AtomicInteger

AtomicInteger 原子整数
可以原子更新的int值。
用于原子递增计数器等应用程序中，不能用作java.lang.Integer的替换。
扩展了Number。

# 1.继承关系：

   public class AtomicInteger extends Number implements java.io.Serializable 
        
    
# 2. 属性、代码块：

    // Unsafe的实例
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // value字段的偏移量
    private static final long valueOffset;

    // 得 value 的偏移量
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    // 用于存储 int 的值。
    private volatile int value;

    
# 3.方法：


   // 构造
   public AtomicInteger(int initialValue) {
       value = initialValue;
   }

   public AtomicInteger() {
   }

   public final int get() {
       return value;
   }

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

   // set的延迟实现，不保证值的改变立即被其他线程看到。
   public final void lazySet(int newValue) {
       unsafe.putOrderedInt(this, valueOffset, newValue);
   }

   // 原子地设置为给定值并返回旧值。
   public final int getAndSet(int newValue) {
       return unsafe.getAndSetInt(this, valueOffset, newValue);
   }

   // compareAndSwapInt方法参数：this操作的对象；
   // valueOffset对象中字段的偏移量；
   // expect原来的值，即期望的值；update要修改的值；
   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);
   }

   // 原子性地自增 1 。
   // 参数：this操作的对象；valueOffset对象中字段的偏移量； 1 要增加的值。
   // 返回的是未自增前的值。
   public final int getAndIncrement() {
       return unsafe.getAndAddInt(this, valueOffset, 1);
   }

   // 原子性地自减 1 。 返回的是未自减前的值。
   public final int getAndDecrement() {
       return unsafe.getAndAddInt(this, valueOffset, -1);
   }

   // 原子地将给定值添加到当前值。
   public final int getAndAdd(int delta) {
       return unsafe.getAndAddInt(this, valueOffset, delta);
   }

   // 原子性地自增 1 。 返回的是自增后的值。
   public final int incrementAndGet() {
       return unsafe.getAndAddInt(this, valueOffset, 1) + 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());
   }

   // 得int、long、float、double值。
   public int intValue() {
       return get();
   }

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

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

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