AtomicIntegerFieldUpdater 源码分析

AtomicIntegerFieldUpdater

AtomicIntegerFieldUpdater 能解决什么问题？什么时候使用 AtomicIntegerFieldUpdater?

1）字段必须是 volatile 类型的实例变量。
2）调用者能够直接通过反射的方式操作对象字段，而不存在可见性问题。

如何使用 AtomicIntegerFieldUpdater?

1）指定对象的 int 值需要支持并发多读少写的场景下，使用 AtomicIntegerFieldUpdater。

使用 AtomicIntegerFieldUpdater 有什么风险？

1）高并发场景下，自旋 CAS 长时间失败会导致 CPU 飙升。

AtomicIntegerFieldUpdater 核心操作的实现原理？

创建实例

    /**
     * 基于指定的 Class 类型和字段名称创建一个 AtomicIntegerFieldUpdater 实例，
     * 字段类型必须是 volatile int。
     */
    @CallerSensitive
    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
            String fieldName) {
        return new AtomicIntegerFieldUpdaterImpl<U>
        (tclass, fieldName, Reflection.getCallerClass());
    }

尝试以原子的方式更新目标对象的 int 值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public boolean compareAndSet(T obj, int expect, int update) {
            accessCheck(obj);
            return AtomicIntegerFieldUpdaterImpl.U.compareAndSetInt(obj, offset, expect, update);
        }

获取此更新器管理的，在给定对象的字段中保持的当前值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int get(T obj) {
            accessCheck(obj);
            return AtomicIntegerFieldUpdaterImpl.U.getIntVolatile(obj, offset);
        }

以原子方式将此更新器管理的给定对象的当前值 + 1，并返回旧值

AtomicIntegerFieldUpdaterImpl#
        public final int getAndIncrement(T obj) {
            return getAndAdd(obj, 1);
        }

        public final int getAndAdd(T obj, int delta) {
            accessCheck(obj);
            return U.getAndAddInt(obj, offset, delta);
        }

        /**
         * 检查目标对象是否是指定 Class 类型的实例
         */
        private void accessCheck(T obj) {
            if (!cclass.isInstance(obj)) {
                throwAccessCheckException(obj);
            }
        }

以原子方式将此更新器管理的给定对象的当前值 - 1，并返回旧值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int getAndDecrement(T obj) {
            return getAndAdd(obj, -1);
        }

以原子方式将此更新器管理的给定对象的当前值 + delta，并返回旧值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int getAndAdd(T obj, int delta) {
            accessCheck(obj);
            return AtomicIntegerFieldUpdaterImpl.U.getAndAddInt(obj, offset, delta);
        }

以原子方式将此更新器管理的给定对象的当前值更新为一元函数式接口的计算值，并返回旧值

    /**
     * 以原子方式将此更新器管理的给定对象的当前值更新为一元函数式接口的计算值，并返回旧值
     */
    public final int getAndUpdate(T obj, IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get(obj);
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

以原子方式将此更新器管理的给定对象的当前值更新为二元函数式接口的计算值，并返回旧值

    /**
     * 以原子方式将此更新器管理的给定对象的当前值更新为二元函数式接口的计算值，并返回旧值
     */
    public final int getAndAccumulate(T obj, int x,
            IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get(obj);
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(obj, prev, next));
        return prev;
    }

以原子方式将此更新器管理的给定对象的当前值 + 1，并返回新值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int incrementAndGet(T obj) {
            return getAndAdd(obj, 1) + 1;
        }

        @Override
        public int getAndAdd(T obj, int delta) {
            accessCheck(obj);
            return AtomicIntegerFieldUpdaterImpl.U.getAndAddInt(obj, offset, delta);
        }

        /**
         * 检查目标对象是否是指定 Class 类型的实例
         */
        private void accessCheck(T obj) {
            if (!cclass.isInstance(obj)) {
                throwAccessCheckException(obj);
            }
        }

以原子方式将此更新器管理的给定对象的当前值 - 1，并返回新值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int decrementAndGet(T obj) {
            return getAndAdd(obj, -1) - 1;
        }

以原子方式将此更新器管理的给定对象的当前值 + delta，并返回新值

AtomicIntegerFieldUpdaterImpl#
        @Override
        public int addAndGet(T obj, int delta) {
            return getAndAdd(obj, delta) + delta;
        }

以原子方式将此更新器管理的给定对象的当前值更新为一元函数式接口的计算值，并返回新值

    /**
     *  以原子方式将此更新器管理的给定对象的当前值更新为一元函数式接口的计算值，并返回新值   
     */
    public final int updateAndGet(T obj, IntUnaryOperator updateFunction) {
        int prev, next;
        do {
            prev = get(obj);
            next = updateFunction.applyAsInt(prev);
        } while (!compareAndSet(obj, prev, next));
        return next;
    }

以原子方式将此更新器管理的给定对象的当前值更新为二元函数式接口的计算值，并返回新值

    /**
     *  以原子方式将此更新器管理的给定对象的当前值更新为二元函数式接口的计算值，并返回新值
     */
    public final int accumulateAndGet(T obj, int x,
            IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get(obj);
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(obj, prev, next));
        return next;
    }