Jdk1.6 JUC源码解析(3)-atomic-AtomicXXXFieldUpdater

Jdk1.6 JUC源码解析(3)-atomic-AtomicXXXFieldUpdater

作者：大飞

 

功能简介：

• 原子域更新器，一般用于一些原子同步结构中。

 

源码分析：

• 首先看下AtomicIntegerFieldUpdater，AtomicIntegerFieldUpdater本身是一个抽象类，提供了一个静态工厂方法来生成实例：

public abstract class  AtomicIntegerFieldUpdater<T>  {
    /**
     * Creates and returns an updater for objects with the given field.
     * The Class argument is needed to check that reflective types and
     * generic types match.
     *
     * @param tclass the class of the objects holding the field
     * @param fieldName the name of the field to be updated
     * @return the updater
     * @throws IllegalArgumentException if the field is not a
     * volatile integer type
     * @throws RuntimeException with a nested reflection-based
     * exception if the class does not hold field or is the wrong type
     */
    @CallerSensitive
    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
        return new AtomicIntegerFieldUpdaterImpl<U>(tclass, fieldName, Reflection.getCallerClass());
    }
    /**
     * Protected do-nothing constructor for use by subclasses.
     */
    protected AtomicIntegerFieldUpdater() {
    }

       这个方法内部会创建一个AtomicIntegerFieldUpdaterImpl的实例。看一下实现：

    private static class AtomicIntegerFieldUpdaterImpl<T> extends AtomicIntegerFieldUpdater<T> {
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private final long offset;
        private final Class<T> tclass;
        private final Class cclass;
        AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName, Class<?> caller) {
            Field field = null;
            int modifiers = 0;
            try {
                field = tclass.getDeclaredField(fieldName);
                modifiers = field.getModifiers();
                sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                    caller, tclass, null, modifiers);
                sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
            } catch(Exception ex) {
                throw new RuntimeException(ex);
            }
            Class fieldt = field.getType();
            if (fieldt != int.class)
                throw new IllegalArgumentException("Must be integer type");
            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");
            this.cclass = (Modifier.isProtected(modifiers) &&
                           caller != tclass) ? caller : null;
            this.tclass = tclass;
            offset = unsafe.objectFieldOffset(field);
        }

       AtomicIntegerFieldUpdaterImpl构造过程中会目标class，和目标域的访问权限、还要要检查目标域是否为int型，是否由volatile修饰、当然还要获取目标域的偏移量，为后面的CAS操作做准备。

       内部基本上就是调用unsafe的方法了，这些方法前面和AtomicInteger源码分析中都描述过了。

        public boolean compareAndSet(T obj, int expect, int update) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.compareAndSwapInt(obj, offset, expect, update);
        }
        public boolean weakCompareAndSet(T obj, int expect, int update) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.compareAndSwapInt(obj, offset, expect, update);
        }
        public void set(T obj, int newValue) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            unsafe.putIntVolatile(obj, offset, newValue);
        }
        public void lazySet(T obj, int newValue) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            unsafe.putOrderedInt(obj, offset, newValue);
        }
        public final int get(T obj) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            return unsafe.getIntVolatile(obj, offset);
        }

       AtomicIntegerFieldUpdater中的其他方法都是基于这些方法来实现的：

    /**
     * Atomically increments by one the current value of the field of the
     * given object managed by this updater.
     *
     * @param obj An object whose field to get and set
     * @return the updated value
     */
    public int incrementAndGet(T obj) {
        for (;;) {
            int current = get(obj);
            int next = current + 1;
            if (compareAndSet(obj, current, next))
                return next;
        }
    }

 

• 再看下AtomicLongFieldUpdater，结构和AtomicIntegerFieldUpdater类似，有一点区别就是，它有两个实现，根据平台是否支持8字节的CAS操作，来选择不同的实现：

public abstract class  AtomicLongFieldUpdater<T>  {
    /**
     * Creates and returns an updater for objects with the given field.
     * The Class argument is needed to check that reflective types and
     * generic types match.
     *
     * @param tclass the class of the objects holding the field
     * @param fieldName the name of the field to be updated.
     * @return the updater
     * @throws IllegalArgumentException if the field is not a
     * volatile long type.
     * @throws RuntimeException with a nested reflection-based
     * exception if the class does not hold field or is the wrong type.
     */
    @CallerSensitive
    public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
        Class<?> caller = Reflection.getCallerClass();
        if (AtomicLong.VM_SUPPORTS_LONG_CAS)
            return new CASUpdater<U>(tclass, fieldName, caller);
        else
            return new LockedUpdater<U>(tclass, fieldName, caller);
    }

       CAS实现就是和AtomicIntegerFieldUpdater中类似的实现，LockedUpdater是实现就是内部加锁：

        public boolean compareAndSet(T obj, long expect, long update) {
            if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
            synchronized(this) {
                long v = unsafe.getLong(obj, offset);
                if (v != expect)
                    return false;
                unsafe.putLong(obj, offset, update);
                return true;
            }
        }

 

 

• 最后看下AtomicReferenceFieldUpdater。

       AtomicReferenceFieldUpdater和AtomicIntegerFieldUpdater类似的结构，AtomicReferenceFieldUpdater一般用于某些原子数据结构中，支持某些节点的引用域的独立原子更新操作。

       其实直接使用AtomicReference也可以完成类似的工作，那么为什么要使用AtomicReferenceFieldUpdater？主要原因还是为了提高性能。假设要设计一个支持原子操作的队列，队列的链接节点必然会进行频繁的操作，如果利用AtomicReference表示这些结点，那么AtomicReference本身的创建过程也需要一些开销，使用AtomicReferenceFieldUpdater可以省去这些开销。

 

       代码细节点之前都分析到过，这里不做详细分析。

 

       好了，源码就分析到这里！