学习笔记：CopyOnWriteArrayList

CopyOnWriteArrayList是一个线程安全的ArrayList，对其进行的修改操作都是在底层的一个复制的数组（快照）上进行的，使用了写时复制策略。

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

    /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
.............
}

每个CopyOnWriteArrayList对象里面有一个array数组对象用来存放具体元素，ReentrantLock独占锁对象用来保证同时只有一个线程对array进行修改。

初始化

1、无参构造函数，创建了一个大小为0的Object数组

/**
     * Creates an empty list.
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

2、入参为集合，将集合里面的元素复制到本list

/**
     * Creates a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection of initially held elements
     * @throws NullPointerException if the specified collection is null
     */
    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);
    }

3、入参为数组

 /**
     * Creates a list holding a copy of the given array.
     *
     * @param toCopyIn the array (a copy of this array is used as the
     *        internal array)
     * @throws NullPointerException if the specified array is null
     */
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

添加元素

两个添加元素的方法原理类似。

public void add(int index, E element) {}
public boolean add(E e) {}

以add(E e)为例：

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

1、获取锁：多个线程都调用add方法则只有一个线程会获取到该锁，其他线程会被阻塞起直到锁被释放
2、添加元素时首先复制了一个快照，然后在快照上进行添加。

获取指定位置元素

 /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return get(getArray(), index);
    }

两步：
1、获取array数组
2、通过下标访问指定位置的元素
整个过程中并没有进行加锁同步。

修改指定元素

 /**
     * Replaces the element at the specified position in this list with the
     * specified element.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);

            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

1、获取独占锁lock.lock();
2、获取当前数组getArray();，并获取指定位置元素get(elements, index);
3、判断指定元素与新元素是否一致，不一致则进行修改。最后都需要重新设置array。

删除元素

public E remove(int index) {}
public boolean remove(Object o) {}
private boolean remove(Object o, Object[] snapshot, int index) {}
void removeRange(int fromIndex, int toIndex) {} 

原理基本上也是
1、获取独占锁以保证删除数据期间其他线程不能对array进行修改
2、获取数组中要被删除的元素，并把剩余元素复制到新数组。

 Object[] newElements = new Object[len - 1];
 System.arraycopy(elements, 0, newElements, 0, index);
 System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);

3、使用新数组替换掉原来的数组，释放锁

弱一致性的迭代器

使用迭代器：

所谓弱一致性是指返回迭代器后，其他线程对list的增删改对迭代器是不可见的。

1、当调用iterator()方法获取迭代器时实际上会返回一个COWIterator对象。

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

2、COWIterator对象的snapshot变量保存了当前list的内容，cursor时遍历list时数据的下标。

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;
     ...........
    }

如果在该线程使用返回的迭代器遍历元素的过程中，其他线程没有对list进行增删改，那么snapshot本身就是list的array，因为他们是引用关系。
如果在遍历期间其他线程对list进行了增删改，那么snapshot就是快照了，因为增删改后list里面的数组被新数组替换了，这时候老数组被snapshot引用。
使用该迭代器元素时，其他线程对该list进行的增删改不可见，因为它们操作的是两个不同的数组，这就是弱一致性。

总结

CopyOnWriteArrayList使用写时复制的策略来保证list的一致性，而获取-修改-写入三步操作并不是原子性的，所以在增删改的过程中都使用了独占锁，来保证在某个时间只有一个线程能对list数组进行修改。
另外CopyOnWriteArrayList提供了弱一致性的迭代器，从而保证在获取迭代器后，其他线程对list的修改是不可见的，迭代器遍历的数组是一个快照。

《Java并发编程之美》