CopyOnWriteArrayList核心源码阅读

Copy-On-Write简称COW，是一种用于集合的并发访问的策略。基本思想是：当我们往一个集合容器中写入元素时（添加、修改、删除），并不会直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后新的容器里写入元素，写入操作完成之后，再将原容器的引用指向新的容器。

CopyOnWriteArrayList相当于一个线程安全的ArrayList，内部存储是Object[]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

final transient ReentrantLock lock = new ReentrantLock();

set()方法  

修改指定下标元素时，会将当前数组Copy复制至新数组，将要修改的新元素替换原数据至数组中，最后替换原数组。在这个过程中，使用ReetantLock加锁，对线程进行保护，保护线程安全避免多个线程复制数组。

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

 Add()方法：

添加新元素至集合时，会将当前数组Copy复制新数组，并将新元素添加至新数组，最后替换原数组。执行过程中，使用ReentrantLock加锁，保证线程安全，避免多个线程复制数组。（重载的add()方法和下述代码实现基本相同）。

public boolean add(E e) {
        //获得锁对象
        final ReentrantLock lock = this.lock;
        //上锁
        lock.lock();
        try {
            //拿到原数组并将原数组长度+1后复制到一个新的数组中
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将要添加的元素放到新数组的最后面
            newElements[len] = e;
            //将新的数组放入
            setArray(newElements);
            return true;
        } finally {
            //添加元素结束后关闭锁
            lock.unlock();
        }
    }

Remove()方法：

删除指定下标元素。根据指定下标，从原数组中，Copy复制其它元素至新数组，最后替换原数组。

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);
            //数组长度-要删除的元素下标值-1
            int numMoved = len - index - 1;
            //判断要删除的元素是不是数组最后一个元素
            if (numMoved == 0)
                //如果是，直接复制最后一个元素之前的所有元素即为删除结果
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                //如果不是，分成2段复制要删除的元素前后的剩余元素
                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();
        }
    }

Get()方法：

根据下标访问数组的元素，这个方法没有加锁，允许多线程并发。但如果在读取的同时有新的元素添加进数组，那么读取到的仍然是旧的数组内容。

@SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    
    public E get(int index) {
        return get(getArray(), index);
    }

CopyOnWriteArrayList的特征：

• 在保证并发读取时，确保了数据写入时的安全；
• 由于每次写入数据都进行了Copy操作，所以数组不需要进行扩容；
• 适合于读多写少的场景，因为add(),set(),remove()等修改方法需要复制整个数组，所以会发生对内存开销过大的问题；
• CopyOnWriteArrayList由于只在修改时加锁，所以只保证数据的最终统一性，不保证数据的实时统一性。