CopyOnWriteArrayList.png

初始化

// 如果是传入的数组，将对其原始的做一份拷贝，再进行初始化
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

// 如果是集合类，将元素转成数组，进行初始化
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);
}

add

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // 重新拷贝一份，长度加一
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 将新的值加到最后位置
        newElements[len] = e;
        // 同步给整个集合array
        setArray(newElements);
        return true;
    } finally {
        // 解锁
        lock.unlock();
    }
}

get

// 从get的实现来看就是去array里面直接获取
// 并没有加锁，加入array变化了的话，其实对于get这里的array没有影响
// 因为修改的情况下，会去重新拷贝array进行update
private E get(Object[] a, int index) {
    return (E) a[index];
}

public E get(int index) {
    return get(getArray(), index);
}

set

public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        Object[] elements = getArray();
        // 拿到index的元素
        E oldValue = get(elements, index);
        // 如果有更新的必要，那么对原有的array进行拷贝，然后进行value的替换
        if (oldValue != element) {
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            newElements[index] = element;
            // 更新整个array
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            // 既然使用的人直到array是个voletile，也知道set的同时要其他人立即可见。那么如果遇到元素
            // 的value一致，如果不进行替换，维持volatile的语义的话。
            // 可能会有某些问题，所以在外部未知的情况下，这里显示去setArray一次，不失为一种保险。
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

remove

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        // 如果是最后一位
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            // 就是在删除index元素的基础上，进行一次拷贝，并更新整个array
            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 {
        lock.unlock();
    }
}

iterator

// 可以看到迭代器会围绕当前的array来进行操作，而之后的更新并不会影响这次生成的迭代器
public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
}