一、简介

二、分析

2.1 类结构

2.1.0 类结构图

2.2 内部类

2.2.0 内部类列表图

• 无

2.3 字段

2.3.0 字段列表图

2.3.1 unsafe

• /**
   * 内部使用Unsafe类的compareAndSwapInt方法进行CAS更新操作
   */
  private static final Unsafe unsafe = Unsafe.getUnsafe();
  

   

2.3.2 value

• /**
   * 内部维护了一个value值，用来存储原子变量值
   */
  private volatile int value;

2.3.3 valueOffset

/**
 * value变量在该类中的偏移量
 */ 
private static final long valueOffset;

2.4 代码块

2.4.0 静态代码块

    static {
        try {
            // 通过Unsafe的方法获取到value变量在该类中的偏移量，用于后面的CAS操作
            valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

2.5 方法

2.5.0 方法列表图

2.5.1 构造函数

/**
 * 无参构造函数 默认值为0
 */
public AtomicInteger() {
}


/**
 * 指定初始值的构造函数，将内部维护的value变量值修改为参数值
 */
public AtomicInteger(int initialValue) {
       value = initialValue;
}

2.5.2 get()

    /**
     * 返回当前的value值
     */
    public final int get() {
         return value;
    }

2.5.3 set(int newValue)

    /**
     * 设置value的值
     */
    public final void set(int newValue) {
        value = newValue;
    }

2.5.4 lazySet(int newValue)

    /**
     * 使用cas操作设置value的值
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }

2.5.5 getAndSet(int newValue)

    /**
     * 使用Unsafe的原子性操作更新value的值并返回旧值
     */
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

2.5.6 compareAndSet(int expect, int update)

    /**
     * 使用Unsafe的原子性操作：如果value的值和expect的值相等，则更新为update,并返回true,否则，返回false
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

2.5.7 weakCompareAndSet(int expect, int update)

    /**
     *  compareAndSet(int expect, int update)方法的替代品，可能会出错，并且不提供顺序保证，很少用
     */
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

2.5.8 getAndIncrement()

    /**
     * 原子操作，使value值增加1然后返回旧值
     */             
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

2.5.9 getAndDecrement()

    /**
     * 原子操作，使得value值减一并返回旧值
     */
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

2.5.10 getAndAdd(int delta)

    /**
     * 原子操作，使得value值增加delta,然后返回旧值
     */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

2.5.11 incrementAndGet()

    /**
     * 原子操作，使得value值增加1后并返回增加后的值
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

2.5.12 decrementAndGet()

    /**
     * 原子操作，使得value值减一并返回新值
     */
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }

2.5.13 addAndGet(int delta)

    /**
     * 原子操作，使得value值增加delta然后返回新值
     */ 
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

2.5.14 getAndUpdate(IntUnaryOperator updateFunction) TODO

    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return prev;
    }

2.5.15 updateAndGet(IntUnaryOperator updateFunction) TODO

    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(prev, next));
        return next;
    }

2.5.16 getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) TODO

    public final int getAndAccumulate(long x, IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return prev;
    }

2.5.17 accumulateAndGet(Int x, LongBinaryOperator accumulatorFunction) TODO

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

2.5.18 toString()

    /**
     * 通过get()方法获取到value值然后返回字符串格式
     */
    public String toString() {
        return Integer.toString(get());
    }

2.5.19 intValue()

    /**
     * 将long类型的get()方法获取到value值强转为int类型，应该存在精度缺失的问题
     */
    public int intValue() {
        return (int)get();
    }

2.5.20 longValue()

    /**
     * 调用get()方法获取到long类型的value值
     */
    public long longValue() {
        return get();
    }

2.5.21 floatValue()

    /**
     * 获取get()方法得到的long类型的value值提升为float类型后的值
     */
    public float floatValue() {
        return (float)get();
    }

2.5.22 doubleValue()

    /**
     * 获取到get()得到的long类型的value值提升为double类型后的值
     */
    public double doubleValue() {
        return (double)get();
    }