AtomicInteger源码解析。

小咪咪 2022-02-04 11:09 232阅读 0赞

/**
     * 
     * 可以用原子方式更新的 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