/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

final Object[] getArray() {
    return array;
}
final void setArray(Object[] a) {
    array = a;
}
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
public CopyOnWriteArrayList(Collection<? extends E> c) {
    Object[] elements;
    if (c.getClass() == CopyOnWriteArrayList.class)
        elements = ((CopyOnWriteArrayList<?>)c).getArray();
    else {
        elements = c.toArray();
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

private E get(Object[] a, int index) {
    return (E) a[index];
}
/**
 * {@inheritDoc}
 *
 * @throws IndexOutOfBoundsException {@inheritDoc}
 */
public E get(int index) {
    return get(getArray(), index);
}

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    //1、加鎖
    lock.lock();
    try {
        //2、取原數(shù)組
        Object[] elements = getArray();
        int len = elements.length;
        //3、拷貝生成新數(shù)組
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        //4、新元素加到數(shù)組最后一位
        newElements[len] = e;
        //5、數(shù)組替換
        setArray(newElements);
        return true;
    } finally {
        //6、釋放鎖
        lock.unlock();
    }
}

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    //1、獲取鎖
    lock.lock();
    try {
        //2、取原數(shù)組
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        //3、如果被刪除元素是數(shù)組最后一位，直接截取len-1的新數(shù)組
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        //4、否則，分段拷貝生成新數(shù)組
        else {
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        //5、釋放鎖
        lock.unlock();
    }
}