int get(int i) //获得当前位置的值
void set(int i, int newValue) //设置给定位置的值
void lazySet(int i, int newValue)
int getAndSet(int i, int newValue)
boolean compareAndSet(int i, int expect, int update)
boolean weakCompareAndSet(int i, int expect, int update)
int getAndIncrement(int i)
int getAndDecrement(int i)
int getAndAdd(int i, int delta)
int incrementAndGet(int i)
int decremnetAndGet(int i)
int addAndGet(int i, int delta)

    private static final Unsafe unsafe = Unsafe.getUnsafe();private static final int base = unsafe.arrayBaseOffset(int[].class);private static final int shift;private final int[] array;

  static {int scale = unsafe.arrayIndexScale(int[].class);          //数组元素的大小，必须为2^x大小if ((scale & (scale - 1)) != 0)throw new Error("data type scale not a power of two");shift = 31 - Integer.numberOfLeadingZeros(scale);   //数组元素的bit偏移量}

   private long checkedByteOffset(int i) {if (i < 0 || i >= array.length)      //索引index越界。throw 异常throw new IndexOutOfBoundsException("index " + i);return byteOffset(i);}private static long byteOffset(int i) {     //取得指定index元素的内存位置（base + offset）return ((long) i << shift) + base;}

 public final int get(int i) {return getRaw(checkedByteOffset(i));} public final void set(int i, int newValue) {unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);}

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

public abstract class  AtomicIntegerFieldUpdater<T>private static class AtomicIntegerFieldUpdaterImpl<T> extends AtomicIntegerFieldUpdater<T>

    public abstract boolean compareAndSet(T obj, int expect, int update);public abstract boolean weakCompareAndSet(T obj, int expect, int update);public abstract void set(T obj, int newValue);public abstract void lazySet(T obj, int newValue);public abstract int get(T obj);

        private final long offset; //成员变量的内存偏移量private final Class<T> tclass; //操作对象的class对象private final Class cclass;  //调用者class对象

sun.reflect.misc.ReflectUtil.ensureMemberAccess( //成员变量访问权限的确定（排除private）
        caller, tclass, null, modifiers);
  sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass); //包访问权限

 Class fieldt = field.getType();if (fieldt != int.class)throw new IllegalArgumentException("Must be integer type");     //变量成员的类型必须为intif (!Modifier.isVolatile(modifiers))                                //变量成员必须要关键字volatile修饰。throw new IllegalArgumentException("Must be volatile type");this.cclass = (Modifier.isProtected(modifiers) &&           //1.当成员为protected时，赋值  cclass = caller(赋值调用者class对象) 2：不为protected时，赋值 cclass = null.caller != tclass) ? caller : null;

 private void fullCheck(T obj) {if (!tclass.isInstance(obj))  //操作对象不为newUpdate()传入的class的实例或子类时，throw. throw new ClassCastException();if (cclass != null)  //上面以分析，当成员没有proteced修饰时， cclass 为null,所以不要进一步检查，直接放行，
                ensureProtectedAccess(obj);}

 private void ensureProtectedAccess(T obj) {if (cclass.isInstance(obj)) {  //当要原子操作的对象obj为调用者class的实例或者子类时，放行，运行原子操作，否则Throw。return;}throw new RuntimeException(new IllegalAccessException("Class " +cclass.getName() +" can not access a protected member of class " +tclass.getName() +" using an instance of " +obj.getClass().getName()));}

private static class Pair<T> {final T reference;final boolean mark;private Pair(T reference, boolean mark) {this.reference = reference;this.mark = mark;}static <T> Pair<T> of(T reference, boolean mark) {return new Pair<T>(reference, mark);}}private volatile Pair<V> pair;

 public boolean compareAndSet(V       expectedReference,V       newReference,boolean expectedMark,boolean newMark) {Pair<V> current = pair;returnexpectedReference == current.reference &&  //在expectReference == current.Ref && expectMark == current.mark 并且新值pair中有任意一个或者两个都不等于目前值时，才更新expectedMark == current.mark &&((newReference == current.reference &&newMark == current.mark) ||casPair(current, Pair.of(newReference, newMark)));}

 private static class Pair<T> {final T reference;final int stamp;private Pair(T reference, int stamp) {this.reference = reference;this.stamp = stamp;}static <T> Pair<T> of(T reference, int stamp) {return new Pair<T>(reference, stamp);}}private volatile Pair<V> pair;

  public boolean compareAndSet(V   expectedReference,V   newReference,int expectedStamp,int newStamp) {Pair<V> current = pair;returnexpectedReference == current.reference &&expectedStamp == current.stamp &&((newReference == current.reference &&newStamp == current.stamp) ||casPair(current, Pair.of(newReference, newStamp)));}