JUC源码解析-CopyOnWriteArrayList

利用写时复制来实现的一个线程安全的ArrayList类，任何对内部数组的更改操作都被锁保护，更改操作都是在拷贝的新数组上进行。

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

    /** 独占锁 */
    final transient ReentrantLock lock = new ReentrantLock();

    /** 数组 */
    private transient volatile Object[] array;

    /**
     * 获取数组
     */
    final Object[] getArray() {
        return array;
    }

    /**
     * 赋值
     */
    final void setArray(Object[] a) {
        array = a;
    }

锁是ReentrantLock，数组array是volatile，所以setArray后array被刷到贮存，并使其它cpu中缓存失效。

构造器

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

可以看出array数组的初始化在构造函数中。

get

    public E get(int index) {
        return get(getArray(), index);
    }
    
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

先是获取到array，再取出元素。可以看出CopyOnWriteArrayList的get操作是弱一致性的，因为获取的array对象可能过时，例如在获取到array后由于其它线程array指向了新的数组对象则当前线程获取的是旧数组的元素，这就有三种情况：1，新旧数组中该位置元素不变。2，新旧数组该位置元素不同，则获取到的便不是最新的值。3，越界，新数组大小改变导致IndexOutOfBoundsException异常。

add

add(E e) ， add(int index , E element) ，addIfAbsent(E e) ， addAllAbsent(Collection c) 等添加操作

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

先获取锁，获取array数组，拷贝一个新数组大小为原数组大小+1，元素插入到新数组尾部，赋值array，最后释放锁。

    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException("Index: "+index+
                                                    ", Size: "+len);
            Object[] newElements;
            int numMoved = len - index; //要移动的元素大小
            if (numMoved == 0) //尾端插入
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                newElements = new Object[len + 1];
                //按index分前后两部分进行拷贝
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

index要是大于数组array长度，抛IndexOutOfBoundsException异常。

// 获取当前array数组，查找是否含有e元素，没有则调用addIfAbsent(e, snapshot)插入
    public boolean addIfAbsent(E e) {
        Object[] snapshot = getArray();
        return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
            addIfAbsent(e, snapshot);
    }

但是这是并发环境，在你得到当前array判断其不含有e元素，调用addIfAbsent(E e, Object[] snapshot)插入操作期间，array可能被其它线程更改，来看看该方法是如何应对的

    private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock(); // 锁
        try {
            Object[] current = getArray();//获取最新的array对象
            int len = current.length;
            if (snapshot != current) { //若是如上所说，在此期间array发生更改
                // 检查新数组中是否含有e元素
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++)
                    if (current[i] != snapshot[i] && eq(e, current[i]))
                        return false;
                if (indexOf(e, current, common, len) >= 0)
                        return false;
            }
            //在current上进行操作
            Object[] newElements = Arrays.copyOf(current, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

它的数里就是获取锁后，再次调用getArray得到最新的array数组，检查其是否含有e元素，若无则插入其尾端。
关于addAll等操作也很简单就不分析了。

set

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

代码很简单，有一点，当发现元素已存在，也就是没必要对数组进行更改时仍调用了setArray，注解说这是为了确保volatile的写语义，那么volatile的写语义是？将数据刷到主存并使其它cpu中该数据的缓存失效，让它们到主存中去获取最新的数据。我想这里调用setArray的主要作用就是让其它cpu中缓存的array对象失效，因为并发下此时其它cpu中缓存的array对象可能各不相同。
volatile的汇编代码里在赋值后会多一步操作lock addl $0x0，(%esp)， lock 前缀，查询 IA32 手册，它的作用是使得本 CPU 的 Cache 写入了内存，该写入动作也会引起别的 CPU 或者别的内核无效化（Invalidate）其 Cache。

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

弱一致性的迭代器

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

    static final class COWIterator<E> implements ListIterator<E> {
        /** array数组的快照 */
        private final Object[] snapshot;
        /** 指针  */
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }
		public void remove() {
            throw new UnsupportedOperationException();
        }
        public void set(E e) {
            throw new UnsupportedOperationException();
        }
        public void add(E e) {
            throw new UnsupportedOperationException();
        }

1，之所以说是若一致性，从iterator()可以看出，迭代器遍历的是调用该方法时的那个array数组。
2，COWIterator是ListIterator。
3，不支持 增/删/改 操作。

其它

CopyOnWrite的应用场景
CopyOnWrite并发容器用于读多写少的并发场景。

CopyOnWrite的缺点
内存占用问题和数据一致性问题。

因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong
GC和Full GC。
针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是10进制的数字，可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其他的并发容器，如ConcurrentHashMap。

数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。