AtomicIntegerFieldUpdater类的实现

介绍：

这个类是基于反射的一个工具类，用于对一个类的 volatile int 的值进行一个原子修改。

详解：

其实这个类的实现和其他的Atomic类的实现差不多，都是一个cas 的原理，只不过在这基础上用了反射来控制对象的字段。

这个类通过一个抽象类，内部有个实现类，通过

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

来构造实现类，而实现类也不复杂，主要做了一些鉴权的工作

  AtomicIntegerFieldUpdaterImpl(final Class tclass,
                                      final String fieldName,
                                      final Class caller) {
            final Field field;
            final int modifiers;
            try {
                //将这个方法作标示为特权方法
                field = AccessController.doPrivileged(
                    new PrivilegedExceptionAction() {
                        public Field run() throws NoSuchFieldException {
                            return tclass.getDeclaredField(fieldName);
                        }
                    });
                //获取修饰符
                modifiers = field.getModifiers();
                //判断调用类对对象类在 modifiers修饰符下有权限调用
                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);
            }

            Class fieldt = field.getType();
            //判断是否是int
            if (fieldt != int.class)
                throw new IllegalArgumentException("Must be integer type");
           //判断是否为volatile
            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");
            //这步是为了之后的权限校验，如果不为null 之后调用会校验包权限
            this.cclass = (Modifier.isProtected(modifiers) &&
                           caller != tclass) ? caller : null;
            this.tclass = tclass;
          //获取偏移量
            offset = unsafe.objectFieldOffset(field);
        }

其他的部分实现和普通的Atomic类差不多，看这个把java权限部分知识补了一下。

参考资料 ：

https://www.ibm.com/developerworks/cn/java/j-lo-rtsecurity/index.html
http://tool.oschina.net/apidocs/apidoc?api=jdk-zh