1、CopyOnWriteArrayList概述

CopyOnWriteArrayList相当于线程安全的ArrayList，底层是一个可变数组。
在这里插入图片描述

特点如下：

线程安全：基于ReentrantLock实现同步；
add/set/remove操作均是基于数组的copy进行；
迭代器进行遍历的速度很快，不会与其他线程发生冲突；
在迭代器上不允许进行的元素更改操作（remove、set和add），因为迭代器依赖于不变的数组快照。

适用于List 大小通常很小，只读操作远多于可变操作，并且需要在遍历期间防止线程冲突。

2、原理 / 源码

在⼤多数的应⽤场景中，读操作的⽐例远远⼤于写操作。当执⾏读操作的时候，对数据是没有修改的，所以，⽆须对数据进⾏加锁操作。⽽针对于写操作的场景中，则需要加锁来保证数据的正确性。

因此，CopyOnWriteArrayList基于volatile关键字 + ReentrantLock 实现互斥访问、保证线程安全性。

内部采用数组存储数据，并且数据被volatile修饰，并且在add/set/remove操作是都会新建一个数组，操作数据都体现在新数组中。操作数据完成之后会将新数组的引用赋值给volatile数组。
- 保存数据的数组array采用volatile修饰，保证了array在线程之间的可见性。当写操作完成后，读操作可以立即感知到新数组的引用。
- 这也是为什么这个List叫CopyOnWrite的原因。
因为操作数据都需要新建一个数组，所以它的数据操作效率不高；但是在遍历的时候，效率比较高，并且写操作也不会阻塞读的操作。
- 写的过程中，从旧数据中读取；保证写数据的同时不影响读数据操作。
在add/set/remove操作数据时，都会先获取互斥锁ReentrantLock，数据操作完毕之后，再释放互斥锁，以达到线程安全的效果。

1）构造函数

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8673264195747942595L;

    /**
     * 监视器锁
     */
    final transient Object lock = new Object();

    /** 一个缓存数组，使用volatile修饰。 */
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    final Object[] getArray() {
        return array;
    }

    /**
     * Sets the 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();
        if (c.getClass() != java.util.ArrayList.class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}

public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

CopyOnWriteArrayList的主体是volatile修饰Object[]；线程安全由互斥锁ReentrantLock保证。
并且由于数组也被transient关键字修饰，所以array数组不会被自动序列化。

2、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;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

方法解析：

执⾏写操作时，⾸先进⾏lock加锁，然后复制原数组创建⼀个⻓度加1的新数组，即：副本数组；
- 当操作新增操作完毕后，将副本数组替换旧的数组。
- 由于array是volatile修饰的，所以替换后，array在多线程之间是可⻅的。
带来的效果就是：
- 执⾏写操作的时候，针对的是副本数组；
- 而读操作，⼀直是针对着原数组；
- 以此做到写操作不会阻塞读操作；

3）get()

//根据index直接获取数组元素
public E get(int index) {
    return elementAt(getArray(), index);
}

读操作非常简单，就是以不加锁的方式从数组中获取对应下标为index的元素。

4）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 {
            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();
    }
}

方法解析：

只要操作数组中的数据，都是先加互斥锁ReentrantLock。
如果被删除的是最后一个元素，则直接通过Arrays.copyOf()进行处理，截取旧数组的前array.length - 1，实际也是新建了一个数组。
否则，直接新建一个数组，将旧数组以index为界限，分两块（不包括index位置的数据）拷贝到新数组中。
操作完成时，更新volatile数组的引用，释放互斥锁。

5）iterator()

public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
}

基于COWIterator进行遍历。

static final class COWIterator<E> implements ListIterator<E> {
    /** Snapshot of the array */
    private final Object[] snapshot;
    /** Index of element to be returned by subsequent call to next.  */
    private int cursor;

    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    public boolean hasNext() {
        return cursor < snapshot.length;
    }

    public boolean hasPrevious() {
        return cursor > 0;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        if (! hasPrevious())
            throw new NoSuchElementException();
        return (E) snapshot[--cursor];
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor-1;
    }

    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code remove}
     *         is not supported by this iterator.
     */
    public void remove() {
        throw new UnsupportedOperationException();
    }

    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code set}
     *         is not supported by this iterator.
     */
    public void set(E e) {
        throw new UnsupportedOperationException();
    }

    /**
     * Not supported. Always throws UnsupportedOperationException.
     * @throws UnsupportedOperationException always; {@code add}
     *         is not supported by this iterator.
     */
    public void add(E e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        Object[] elements = snapshot;
        final int size = elements.length;
        for (int i = cursor; i < size; i++) {
            @SuppressWarnings("unchecked") E e = (E) elements[i];
            action.accept(e);
        }
        cursor = size;
    }
}