AtomicIntegerFieldUpdater

如果一个类是自己编写的，则可以在编写的时候把成员变量定义为Atomic类型。但如果是一个已经有的类，在不能更改其源代码的情况下，要想实现对其成员变量的原子操作，就需要AtomicIntegerFieldUpdater、AtomicLongFieldUpdater 和 AtomicReferenceFieldUpdater。

AtomicIntegerFieldUpdater的使用

    public static void main(String[] args) {
        Student student = new Student();
        //创建AtomicIntegerFieldUpdater对象
        AtomicIntegerFieldUpdater<Student> studentAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Student.class, "age");
        //打印age并将age+1
        System.out.println(studentAtomicIntegerFieldUpdater.getAndIncrement(student));
        System.out.println(student.age);
    }
//测试类   
public class Student {
	//因为是用反射实现的这里必须要使用public修饰
    public volatile int  age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

要修改的age必须是int不能是包装类Integer,必须被volatile修饰

AtomicIntegerFieldUpdater代码实现

	//AtomicIntegerFieldUpdater的无参构造被protected修饰,使用newUpdater创建对象
    protected AtomicIntegerFieldUpdater() {
    }

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

			AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,
                                      final String fieldName,
                                      final Class<?> caller) {
            final Field field;
            final int modifiers;
            try {
            	//反射获得属性，这里是student的age
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction<Field>() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                //判断age是不是public
                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);
            }
			//判断是不是int类型
            if (field.getType() != int.class)
                throw new IllegalArgumentException("Must be integer type");
			//判断是不是被volatile修饰
            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;
            //Unsafe类获得age属性的偏移量
            this.offset = U.objectFieldOffset(field);
        }

getAndIncrement方法

        public final int getAndIncrement(T obj) {
        	//age+1
            return getAndAdd(obj, 1);
        }

        public final int getAndAdd(T obj, int delta) {
        	//检查obj和声明AtomicIntegerFieldUpdater时的class一不一样
            accessCheck(obj);
            //Unsafe类获得age的值并且使用compareAndSwapInt将age+1
            return U.getAndAddInt(obj, offset, delta);
        }

AtomicLongFieldUpdater 和 AtomicReferenceFieldUpdater和AtomicIntegerFieldUpdater类似