048_java.util.concurrent.atomic.AtomicIntegerFieldUpdater

简单描述

AtomicIntegerFieldUpdater 是针对一个对象下的值域进行变更的原子类。与此实现类似的还有AtomicLongFieldUpdater，AtomicReferenceFieldUpdater。

构造函数

AtomicIntegerFieldUpdater本身是一个抽象类，因此不能进行实例化。但是它提供了实例的构造器：

// AtomicIntegerFieldUpdater
@CallerSensitive
public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
                                                          String fieldName) {
    return new AtomicIntegerFieldUpdaterImpl<U>
        (tclass, fieldName, Reflection.getCallerClass());
}

// AtomicIntegerFieldUpdater.AtomicIntegerFieldUpdaterImpl 内部类
AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
                                      final String fieldName,
                                      final Class<?> caller) {
            final Field field;
            final int modifiers;
            try {
                // 权限相关
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                modifiers = field.getModifiers();
                // 字段权限校验
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                ClassLoader cl = tclass.getClassLoader();
                ClassLoader ccl = caller.getClassLoader();
                // 类加载器与权限校验
                if ((ccl != null) && (ccl != cl) &&
                    ((cl == null) || !isAncestor(cl, ccl))) {
                    sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
                }
            } catch (PrivilegedActionException pae) {
                throw new RuntimeException(pae.getException());
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }

            // 字段类型校验
            if (field.getType() != int.class)
                throw new IllegalArgumentException("Must be integer type");

            // 字段必须使用violate修饰
            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

            this.cclass = (Modifier.isProtected(modifiers) &&
                           tclass.isAssignableFrom(caller) &&
                           !isSamePackage(tclass, caller))
                          ? caller : tclass;
            this.tclass = tclass;
            this.offset = U.objectFieldOffset(field);
        }

可以看到，AtomicIntegerFieldUpdater提供newUpdater方法，接受类与字段名作为初始化参数。最终行为执行在AtomicIntegerFieldUpdaterImpl类中。

重要方法

方法都较为雷同，这里都展示出来：

// 针对obj，使用expect进行比较，匹配则使用update进行更新，更新成功则返回true
public final boolean compareAndSet(T obj, int expect, int update) {
    accessCheck(obj);
    return U.compareAndSwapInt(obj, offset, expect, update);
}

// 针对obj，使用expect进行比较，匹配则使用update进行更新，更新成功则返回true
// 不保证指令的有序性
public final boolean weakCompareAndSet(T obj, int expect, int update) {
    accessCheck(obj);
    return U.compareAndSwapInt(obj, offset, expect, update);
}

// 针对obj，使用newValue进行赋值
public final void set(T obj, int newValue) {
    accessCheck(obj);
    U.putIntVolatile(obj, offset, newValue);
}

// 针对obj，使用newValue进行赋值，只有最后get的时候会强刷主内存进行更新赋值
public final void lazySet(T obj, int newValue) {
    accessCheck(obj);
    U.putOrderedInt(obj, offset, newValue);
}

// 从obj内获得其数据
public final int get(T obj) {
    accessCheck(obj);
    return U.getIntVolatile(obj, offset);
}

// 针对obj，赋值 newValue，返回旧值
public final int getAndSet(T obj, int newValue) {
    accessCheck(obj);
    return U.getAndSetInt(obj, offset, newValue);
}

// 针对obj，赋值 delta，返回旧值
public final int getAndAdd(T obj, int delta) {
    accessCheck(obj);
    return U.getAndAddInt(obj, offset, delta);
}

// 针对obj，字段加一，返回旧值
public final int getAndIncrement(T obj) {
    return getAndAdd(obj, 1);
}

// 针对obj，字段-1，返回旧值
public final int getAndDecrement(T obj) {
    return getAndAdd(obj, -1);
}

// 针对obj，字段加一，返回新值
public final int incrementAndGet(T obj) {
    return getAndAdd(obj, 1) + 1;
}

// 针对obj，字段减一，返回新值
public final int decrementAndGet(T obj) {
    return getAndAdd(obj, -1) - 1;
}

// 针对obj，字段加delta，返回新值
public final int addAndGet(T obj, int delta) {
    return getAndAdd(obj, delta) + delta;
}

总结