Atomic

public class AtomicBoolean extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // 记录value字段相对于对象的起始内存地址的字节偏移量，主要是为了在更新操作在内存中找到value的位置，方便比较。
    private static final long valueOffset;
    // 内存值为 int 类型的 0 或 1
    private volatile int value;

    static {
        try 
        {
            // 获取value字段相对于对象的起始内存地址的字节偏移量
            valueOffset = unsafe.objectFieldOffset(AtomicBoolean.class.getDeclaredField("value"));
        } catch (Exception ex) {
            throw new Error(ex);
        }

    }
    
    public AtomicBoolean(boolean initialValue) {
        value = initialValue ? 1 : 0;
    }
}

// AtomicLongFieldUpdater 中会根据此字段而使用不同的实现类
static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();

public class AtomicIntegerArray implements java.io.Serializable {
    private static final long serialVersionUID = -2308431214976778248L;

    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占4个byte,所以此处scale=4
        int scale = unsafe.arrayIndexScale(int[].class);
        if ((scale & (scale - 1)) != 0)
　　　　　　　　　　　　　　　　// 数据类型规模不是2的幂
            throw new Error("data type scale not a power of two");
        //  numberOfLeadingZeros() 在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量
        //  31减去前导零(数字变成二进制后前面0的个数),这里shift 为 2
        shift = 31 - Integer.numberOfLeadingZeros(scale);
    }
    // i 数组下标
    public final int get(int i) {
        return getRaw(checkedByteOffset(i));
    }
    // offset 指定下标的元素相对于 array 的偏移量
    private long getRaw(long offset) {
        return unsafe.getLongVolatile(array, offset);
    }
    // 判断下标是否越界
    private long checkedByteOffset(int i) {
        if (i < 0 || i >= array.length)
            throw new IndexOutOfBoundsException("index " + i);

        return byteOffset(i);
    }
    // 返回指定下标的元素相对于 array 的偏移量
    private static long byteOffset(int i) {
        // 基地址 + (第 i 个元素)  i * 4(一个int4个byte)
        return ((long) i << shift) + base;
    }

}

public class AtomicReferenceArray<E> implements java.io.Serializable {
    private static final long serialVersionUID = -6209656149925076980L;

    private static final Unsafe unsafe;
    private static final int base;
    private static final int shift;
    private static final long arrayFieldOffset;
    private final Object[] array; // must have exact type Object[]

    static {
        try {
            unsafe = Unsafe.getUnsafe();
　　　　　　　// 获取 array 相对于对象的偏移量　
            arrayFieldOffset = unsafe.objectFieldOffset
                (AtomicReferenceArray.class.getDeclaredField("array"));
            base = unsafe.arrayBaseOffset(Object[].class);
            int scale = unsafe.arrayIndexScale(Object[].class);
            if ((scale & (scale - 1)) != 0)
                throw new Error("data type scale not a power of two");
            shift = 31 - Integer.numberOfLeadingZeros(scale);
        } catch (Exception e) {
            throw new Error(e);
        }
    }


}

public abstract class AtomicIntegerFieldUpdater<T> {

    // 构造方法同一个package及子类可调用
    protected AtomicIntegerFieldUpdater() {
    }

    // AtomicIntegerFieldUpdater是一个抽象类，但是它内部有一个private final类型的默认子类，
    // 所以在调用newUpdater的时候，返回一个 AtomicIntegerFieldUpdaterImpl 实例
    // 一般通过该实例调用相关方法
    @CallerSensitive
    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
        return new AtomicIntegerFieldUpdaterImpl<U>(tclass, fieldName, Reflection.getCallerClass());
    }
}
// 示例
public class Demo {

    volatile int number;

    public static void main(String[] args) {

        AtomicIntegerFieldUpdater<Demo> newUpdater = AtomicIntegerFieldUpdater.newUpdater(Demo.class, "number");
        newUpdater.incrementAndGet(new Demo());
    }
}

public abstract class AtomicLongFieldUpdater<T> {

    @CallerSensitive
    public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass,
                                                           String fieldName) {
        Class<?> caller = Reflection.getCallerClass();
　　　　  // 虚拟机是否支持Long类型的CAS操作
        if (AtomicLong.VM_SUPPORTS_LONG_CAS)
            return new CASUpdater<U>(tclass, fieldName, caller);
        else
            return new LockedUpdater<U>(tclass, fieldName, caller);
    }
}

public abstract class AtomicReferenceFieldUpdater<T,V> {

    @CallerSensitive
    public static <U,W> AtomicReferenceFieldUpdater<U,W> newUpdater(Class<U> tclass,
                                                                    Class<W> vclass,
                                                                    String fieldName) {
        return new AtomicReferenceFieldUpdaterImpl<U,W>
            (tclass, vclass, fieldName, Reflection.getCallerClass());
    }
}