AtomicIntegerArray源码分析与感悟

在讲AtomicIntegerArray之前，我先通过AtomicInteger阐述一下juc原子包的实现原理：

     private volatile int value; // 注意是volatile类型的变量，可见性（一个线程对该值修改后，会马上同步到主内存，其

                                             //他线程能马上看到新值）

     public final int getAndSet(int newValue) { 
        for (;;) {          // 使用循环重试与(比较并设置 cas),
            int current = get();                                           // 首先先获取当前值
            if (compareAndSet(current, newValue))      // 然后原子性执行比较并设置，如果在设置值的时候，原先的值是                                                                                   /刚获取的值，表示，该线程在调用 int current = get()方法后，执行compareAndSet之前没有其他线程修改过该值，则原子性更新为新的值，否则，重试。
                return current;
        }
    }

AtomicIntegerArray，提供了一个原子访问数据中元素方法的一种途径。

    对于这类原子操作，在理解上应该没什么问题，通过AtomitoIntegerArray，我学到如下几个关键点：

   1）int  sacle = unsafe.arrayIndexScale（int[].class）与  int base = unsafe.arrayBaseOffset(Int[].class);

       其中 unsafe.arrayBaseOffset 获取该类型的数组，在对象存储时，存放第一个元素的内存地址，相对于数组对象起始地址的内存偏移量。

                unsafe.arrayIndexSacle(int[].class) 获取该类型的数组中元素的大小，占用多少个字节。

   2） 根据scale ，base 如何准备定位到任意一个下标的地址呢？请查看如下关键代码块

       

static {        int scale = unsafe.arrayIndexScale(int[].class);        if ((scale & (scale - 1)) != 0)            throw new Error("data type scale not a power of two");        shift = 31 - Integer.numberOfLeadingZeros(scale);    }    private long checkedByteOffset(int i) {        if (i < 0 || i >= array.length)            throw new IndexOutOfBoundsException("index " + i);        return byteOffset(i);    }    private static long byteOffset(int i) {        return ((long) i << shift) + base;    }

用于定位元素偏移量的控制值

举例说明，int scale = 4;1个int类型，在java中占用4个字节。

Integer.numberOfLeadingZeros(scale); 返回 scale 高位连续0的个数，得出shift = 2, 而shift在如下方法使用

得出结论了吧，shift就是 用来定位数组中的内存位置，用来移位用的，每向左移动移位，在不越界的情况下，想当于乘以2。也就是int类型的长度为4，也就是第0个位置是0，第1(i)个位置是4,，第二个(i)位置是8，也就是偏移位置等于  i * 4,也就是  i << 2;总结出一个乘法转换成移位操作的案例： a * (一个2的幂(n)的数)  =  a << n; 给出一个指定2的幂的数，怎么算成n,,参照shift的计算方法。 

附上AtomicIntegerArray 源码

/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. *  *//* * * * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */package java.util.concurrent.atomic;import sun.misc.Unsafe;import java.util.*;/** * An {@code int} array in which elements may be updated atomically. * See the {@link java.util.concurrent.atomic} package * specification for description of the properties of atomic * variables. * @since 1.5 * @author Doug Lea */public class AtomicIntegerArray implements java.io.Serializable {    private static final long serialVersionUID = 2862133569453604235L;    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);        if ((scale & (scale - 1)) != 0)            throw new Error("data type scale not a power of two");        shift = 31 - Integer.numberOfLeadingZeros(scale);    }    private long checkedByteOffset(int i) {        if (i < 0 || i >= array.length)            throw new IndexOutOfBoundsException("index " + i);        return byteOffset(i);    }    private static long byteOffset(int i) {        return ((long) i << shift) + base;    }    /**     * Creates a new AtomicIntegerArray of the given length, with all     * elements initially zero.     *     * @param length the length of the array     */    public AtomicIntegerArray(int length) {        array = new int[length];    }    /**     * Creates a new AtomicIntegerArray with the same length as, and     * all elements copied from, the given array.     *     * @param array the array to copy elements from     * @throws NullPointerException if array is null     */    public AtomicIntegerArray(int[] array) {        // Visibility guaranteed by final field guarantees        this.array = array.clone();    }    /**     * Returns the length of the array.     *     * @return the length of the array     */    public final int length() {        return array.length;    }    /**     * Gets the current value at position {@code i}.     *     * @param i the index     * @return the current value     */    public final int get(int i) {        return getRaw(checkedByteOffset(i));    }    private int getRaw(long offset) {        return unsafe.getIntVolatile(array, offset);    }    /**     * Sets the element at position {@code i} to the given value.     *     * @param i the index     * @param newValue the new value     */    public final void set(int i, int newValue) {        unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);    }    /**     * Eventually sets the element at position {@code i} to the given value.     *     * @param i the index     * @param newValue the new value     * @since 1.6     */    public final void lazySet(int i, int newValue) {        unsafe.putOrderedInt(array, checkedByteOffset(i), newValue);    }    /**     * Atomically sets the element at position {@code i} to the given     * value and returns the old value.     *     * @param i the index     * @param newValue the new value     * @return the previous value     */    public final int getAndSet(int i, int newValue) {        long offset = checkedByteOffset(i);        while (true) {            int current = getRaw(offset);            if (compareAndSetRaw(offset, current, newValue))                return current;        }    }    /**     * Atomically sets the element at position {@code i} to the given     * updated value if the current value {@code ==} the expected value.     *     * @param i the index     * @param expect the expected value     * @param update the new value     * @return true if successful. False return indicates that     * the actual value was not equal to the expected value.     */    public final boolean compareAndSet(int i, int expect, int update) {        return compareAndSetRaw(checkedByteOffset(i), expect, update);    }    private boolean compareAndSetRaw(long offset, int expect, int update) {        return unsafe.compareAndSwapInt(array, offset, expect, update);    }    /**     * Atomically sets the element at position {@code i} to the given     * updated value if the current value {@code ==} the expected value.     *     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>     * and does not provide ordering guarantees, so is only rarely an     * appropriate alternative to {@code compareAndSet}.     *     * @param i the index     * @param expect the expected value     * @param update the new value     * @return true if successful.     */    public final boolean weakCompareAndSet(int i, int expect, int update) {        return compareAndSet(i, expect, update);    }    /**     * Atomically increments by one the element at index {@code i}.     *     * @param i the index     * @return the previous value     */    public final int getAndIncrement(int i) {        return getAndAdd(i, 1);    }    /**     * Atomically decrements by one the element at index {@code i}.     *     * @param i the index     * @return the previous value     */    public final int getAndDecrement(int i) {        return getAndAdd(i, -1);    }    /**     * Atomically adds the given value to the element at index {@code i}.     *     * @param i the index     * @param delta the value to add     * @return the previous value     */    public final int getAndAdd(int i, int delta) {        long offset = checkedByteOffset(i);        while (true) {            int current = getRaw(offset);            if (compareAndSetRaw(offset, current, current + delta))                return current;        }    }    /**     * Atomically increments by one the element at index {@code i}.     *     * @param i the index     * @return the updated value     */    public final int incrementAndGet(int i) {        return addAndGet(i, 1);    }    /**     * Atomically decrements by one the element at index {@code i}.     *     * @param i the index     * @return the updated value     */    public final int decrementAndGet(int i) {        return addAndGet(i, -1);    }    /**     * Atomically adds the given value to the element at index {@code i}.     *     * @param i the index     * @param delta the value to add     * @return the updated value     */    public final int addAndGet(int i, int delta) {        long offset = checkedByteOffset(i);        while (true) {            int current = getRaw(offset);            int next = current + delta;            if (compareAndSetRaw(offset, current, next))                return next;        }    }    /**     * Returns the String representation of the current values of array.     * @return the String representation of the current values of array     */    public String toString() {        int iMax = array.length - 1;        if (iMax == -1)            return "[]";        StringBuilder b = new StringBuilder();        b.append('[');        for (int i = 0; ; i++) {            b.append(getRaw(byteOffset(i)));            if (i == iMax)                return b.append(']').toString();            b.append(',').append(' ');        }    }}