AtomicInteger源码解析。

版权声明：转载需说明出处。 https://blog.csdn.net/en_joker/article/details/89923787

/**
 * 
 * 可以用原子方式更新的 int 值。
 * AtomicInteger 可用在应用程序中（如以原子方式增加的计数器），并且不能用于替换 Integer。但是，此类确实扩展了
 * Number，允许那些处理基于数字类的工具和实用工具进行统一访问。
 */
public class AtomicInteger extends Number implements java.io.Serializable {

    private static final long serialVersionUID = 6214790243416807050L;
    
    // 设置为使用Unsafe.compareAndSwapInt进行更新
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    //变量value的内存首地址的偏移量。
    private static final long valueOffset;
    
    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    // 当前值
    private volatile int value;
    
    /**
     * 创建具有给定初始值的新 AtomicInteger。
     * @param initialValue	初始值
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    
    /**
     * 创建具有初始值 0 的新 AtomicInteger。 
     */
    public AtomicInteger() {
    }
    
    /**
     * 获取当前值。
     * @return 当前值 
     */
    public final int get() {
        return value;
    }
    
    /**
     * 设置为给定值。
     * @param newValue 新值
     */
    public final void set(int newValue) {
        value = newValue;
    }
    
    /**
     * 最后设置为给定值。
     * @param newValue 新值
     */
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }
    
    /**
     * 以原子方式设置为给定值，并返回旧值。
     * @param newValue	新值
     * @return 以前的值
     */
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
    
    /**
     * 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
     * @param expect	预期值
     * @param update	新值
     * @return 如果成功，则返回 true。返回 False 指示实际值与预期值不相等。
     * @time 2019年5月7日 下午4:04:06
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * 如果当前值 == 预期值，则以原子方式将该设置为给定的更新值。 
     * 可能意外失败并且不提供排序保证，所以只有在很少的情况下才对 compareAndSet 进行适当地选择。
     * @param expect	预期值
     * @param update	新值 
     * @return 如果成功，则返回 true。
     * @time 2019年5月7日 下午4:04:58
     */
    public final boolean weakCompareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    
    /**
     * 以原子方式将当前值加 1。
     * @return 以前的值
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    
    /**
     * 以原子方式将当前值减 1。 
     * @return 以前的值
     */
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }
    
    /**
     * 以原子方式将给定值与当前值相加。
     * @param delta	要加上的值
     * @return 以前的值
     */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    
    /**
     * 以原子方式将当前值加 1。 
     * @return 更新的值
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    
    /**
     * 以原子方式将当前值减 1。
     * @return 更新的值
     */
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
    
    /**
     * 以原子方式将给定值与当前值相加。 
     * @param delta	要加上的值 
     * @return 更新的值
     */
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }
    
    /**
     * 用应用给定函数的结果原子更新当前值，返回上一个值。 
     * 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 
     * @param updateFunction	无副作用的函数
     * @return 以前的值
     */
    public final int getAndUpdate(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev); // 将prev应用于函数中。
        } while (!compareAndSet(prev, next));
        return prev;
    }
    
    /**
     * 使用给定函数的结果原子更新当前值，返回更新的值。 
     * 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 
     * @param updateFunction	无副作用的功能 
     * @return 更新的值
     */
    public final int updateAndGet(IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get();
            next = updateFunction.applyAsInt(prev); // 将prev应用于函数中。
        } while (!compareAndSet(prev, next));
        return next;
    }
    
    /**
     * 使用给定函数应用给当前值和给定值的结果原子更新当前值，返回上一个值。 
     * 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 
     * 该函数应用当前值作为其第一个参数，给定的更新作为第二个参数。 
     * @param x	更新值
     * @param accumulatorFunction	两个参数的无效副作用
     * @return 以前的值
     */
	public final int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) {
		int prev, next;
		do {
			prev = get();
			next = accumulatorFunction.applyAsInt(prev, x); // 将prev和x应用于函数中。
		} while (!compareAndSet(prev, next));
		return prev;
	}
	
	/**
	 * 使用将给定函数应用于当前值和给定值的结果原子更新当前值，返回更新后的值。 
	 * 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 
	 * 该函数应用当前值作为其第一个参数，给定的更新作为第二个参数。 
	 * @param x	 更新值
	 * @param accumulatorFunction	两个参数的无副作用的函数 
	 * @return 更新的值
	 */
	public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) {
		int prev, next;
		do {
			prev = get();
			next = accumulatorFunction.applyAsInt(prev, x);// 将prev和x应用于函数中。
		} while (!compareAndSet(prev, next));
		return next;
	}
	
	/**
	 * 返回当前值的字符串表示形式。 
	 * 实现：类 Object 中的 toString
	 */
    public String toString() {
        return Integer.toString(get());
    }
	
    /**
     * 以 int 形式返回指定的数值。这可能会涉及到舍入或取整。 
     * 实现：类 Number 中的 intValue
     */
	@Override
    public int intValue() {
        return get();
    }

	/**
	 * 以 long 形式返回指定的数值。这可能涉及到舍入或取整。 
	 * 实现：类 Number 中的 longValue
	 */
	@Override
    public long longValue() {
        return (long)get();
    }

	/**
	 * 以 float 形式返回指定的数值。这可能会涉及到舍入。 
	 * 实现：类 Number 中的 floatValue
	 */
	@Override
    public float floatValue() {
        return (float)get();
    }

	/**
	 * 以 double 形式返回指定的数值。这可能会涉及到舍入。
	 * 实现：类 Number 中的 doubleValue
	 */
	@Override
    public double doubleValue() {
        return (double)get();
    }
}

参考文献：JDK 1.6 API

                  JDK 1.8 API