CopyOnWriteArrayList实现了List接口，RandomAccess，Cloneable，Serializable接口。

1、线程安全，在多线程环境下作为共享变量可以放心使用，无需加锁。
2、通过加锁和volatile保证安全
3、每次对数组进行增删改操作都会复制原先元素到新的数组中，在新的数组上进行操作，最后再赋值回去。

他底层使用的数据结构也是数组，对数组中元素的操作都会经历，加锁，拷贝原数组到新数组中，对新数组进行增删改，然后赋值回旧的数组，最后解锁。

除了这些操作外，CopyOnWriteArrayList内的array数组是被volatile和transient修饰的。

从类注释中，我们可以知道CopyOnWriteArrayList是线程安全的集合类，因为增删改都是在新的数组中进行的，当更新完成后，新数组又被赋值给原先数组，这样所有线程都可以知道哪些元素被修改了。
虽然数组的拷贝开销较大，但是往往比常用的方案效率要好。
在迭代过程中，不会抛出ConcurrentModificationException，因为并不是在原先数组上修改的。

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        // 手动加锁
        lock.lock();
        try {
            // 旧数组
            Object[] elements = getArray();
            // 原先数组长度
            int len = elements.length;
            // 新数组是旧数组的拷贝，且容量+1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            // 直接将新元素e赋值给新数组的最后
            newElements[len] = e;
            // 设置给原数组array，array = newElements
            setArray(newElements);
            return true;
        } finally {
        // 最后释放锁
            lock.unlock();
        }
    }

在整个add的过程中都是加锁的，所以在同一时刻只有一个线程可以add成功，既然已经加锁，那为什么还要创建新数组进行拷贝呢？这是因为原先数组是volatile修饰的，如果我们简单的在原来数组上修改其中某几个元素的值，是无法触发可见性的，我们必须通过修改数组的内存地址才行，也就说要对数组进行重新赋值才行。通过新建一个数组拷贝旧的数组，是可以避免在赋值过程中出现旧数组值被改变的情况。

当在指定位置插入时，如果插入元素的位置时最后一个，那么只需要拷贝一次，如果在中间位置插入时，需要拷贝两次(将数组一分为二)；

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];
                // 否则进行两次拷贝
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            // 给新元素赋值
            newElements[index] = element;
            // 设置新数组
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }


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);
            // 减一是因为len是从1开始的，index是从0开始的
            int numMoved = len - index - 1;
            if (numMoved == 0)// 如果删除的是最后一个，直接删除
                setArray(Arrays.copyOf(elements, len - 1));
            else {
            // 如果删除的是中间元素，新建的数组大小-1，并且从0拷贝到删除元素前，从删除元素的后一个拷贝到最后
                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();
        }
    }

删除元素的思路就是
1、加锁
2、根据删除元素的下标确定在数组中的位置，然后采取不同的策略删除
3、解锁
不管事新增还是删除，lock对象都是被final修饰的，他们都共用一把锁，try finally+数组拷贝保证了能够成功删除指定元素。

该集合类的优点是：读取元素不需要加锁，适合读多写少的场景。例如：读取白名单，黑名单等。
缺点也很明显：内存开销比在原数组上修改多了一倍内存占用，可能导致年轻代GC，如果要求强一致性就不能使用这个了。