Java并发编程之CopyOnWriteArrayList

什么是CopyOnWrite

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。

什么是CopyOnWrite容器

CopyOnWrite容器即写时复制的容器。当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

初识CopyOnWriteArrayList

CopyOnWriteArrayList，即CopyOnWrite+ArrayList，CopyOnWrite我们上面提到过这是一种优化策略，而ArrayList实际上是一个数组。从而我们可知，CopyOnWriteArrayList是一种采用COW优化策略，且底层实现为数组的容器。

CopyOnWriteArrayList的继承关系

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

CopyOnWriteArrayList的部分属性

	// 可重入锁
    final transient ReentrantLock lock = new ReentrantLock();
    // 对象数组，用于存放元素
    private transient volatile Object[] array;

可重入锁用来保证线程安全访问

CopyOnWriteArrayList的构造函数

public CopyOnWriteArrayList() {
        // 设置数组
        setArray(new Object[0]);
}

创建一个空列表

	public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class) // 类型相同
            // 获取c集合的数组
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else { // 类型不相同
            // 将c集合转化为数组并赋值给elements
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class) // elements类型不为Object[]类型
                // 将elements数组转化为Object[]类型的数组
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        // 设置数组
        setArray(elements);
    }

创建一个按 collection 的迭代器返回元素的顺序包含指定 collection 元素的列表。

CopyOnWriteArrayList的方法

add操作

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

将指定元素添加到此列表的尾部

	private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            if (snapshot != current) { // 快照不等于当前数组，对数组进行了修改
                // 取较小者
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++) // 遍历
                    if (current[i] != snapshot[i] && eq(e, current[i])) // 当前数组的元素与快照的元素不相等并且e与当前元素相等
                        // 表示在snapshot与current之间修改了数组，并且设置了数组某一元素为e，已经存在
                        return false;
                if (indexOf(e, current, common, len) >= 0) // 在当前数组中找到e元素
                        return false;
            }
            Object[] newElements = Arrays.copyOf(current, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

用于添加元素，若元素在数组中不存在则添加，若存在则直接返回，该函数可以保证多线程环境下不会重复添加元素。

set操作

	public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            // 获取index索引的元素
            E oldValue = get(elements, index);

            if (oldValue != element) { // 旧值等于element
                int len = elements.length;
                // 复制数组
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                // 设置数组
                setArray(newElements);
            } else {
                // 设置数组
                setArray(elements);
            }
            // 返回旧值
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

用指定的元素替代此列表指定位置上的元素

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) // 移动个数为0
                // 复制后设置数组
                setArray(Arrays.copyOf(elements, len - 1));
            else { // 移动个数不为0
                Object[] newElements = new Object[len - 1];
                // 复制index索引之前的元素
                System.arraycopy(elements, 0, newElements, 0, index);
                // 复制index索引之后的元素
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                // 设置索引
                setArray(newElements);
            }
            // 返回旧值
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

移除此列表指定位置上的元素

分析CopyOnWriteArrayList的缺点

1. 内存占用问题。因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象。如果这些对象占用的内存比较大，那么这个时候很有可能造成频繁的Yong GC和Full GC。
2. 数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

参考：【JUC】JDK1.8源码分析之CopyOnWriteArrayList（六）
Java并发编程：并发容器之CopyOnWriteArrayList（转载）