1.1 介绍

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

CopyOnWriteArrayList类图

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

5.2 主要方法源码解析

5.2.1 添加元素

内部有很多添加元素的方法
以为add(E e)为例进行说明

 /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        //获取独占锁，如果多个线程都调用add方法则只有一个线程会获取到该锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
//复制array到新数组，添加元素到新数组（新数组的大小是原数组大小增加1，所以CopyOnWriteArrayList是无界锁）
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
//使用新数组替换添加元素前的数组
            setArray(newElements);
            return true;
        } finally {
//释放独占锁
            lock.unlock();
        }
    }

总结：
在添加元素时首先复制了一个快照，然后再快照上进行添加，而不是直接在原来的数组上进行。

5.2.2 获取元素

get方法获取元素
获取元素分为两步：

1. 获取array数组；
2. 通过index访问指定index位置处的元素。
   注意在上述过程中并没有加锁的步骤，这就导致了假如有x、y两个线程。x线程get元素，y线程remove元素。x线程在执行完步骤1后y线程获得执行权，此时y线程获取独占锁，然后删除了x要获取的index位置的元素，但是x线程内保存的数组依旧是原来的线程，发生了幻读。这就是写时复制策略产生的若一致性问题。

5.2.3 修改指定元素

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

5.2.4 删除元素

 /**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the list.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    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();
        }
    }

5.2.5 弱一致性的迭代器

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

package beautyofparllel;

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class copyList {
    private static volatile CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<String>();

    public static void main(final String[] args) throws InterruptedException {
        arrayList.add("hello");
        arrayList.add("alibaba");
        arrayList.add("welcome");
        arrayList.add("to");
        arrayList.add("hangzhou");
        Thread thread = new Thread(() -> {
           arrayList.set(1,"baba");
           arrayList.remove(2);
           arrayList.remove(3);
        });
        //保证在修改线程启动前获取迭代器
        Iterator<String> iterator = arrayList.iterator();
        thread.start();
        //等待子线程执行完毕
        thread.join();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

并未获得增删改的结果，这就是弱一致性的体现