并发和多线程(十七)--CopyOnWriteArrayList源码解析

本文主要是介绍并发和多线程(十七)--CopyOnWriteArrayList源码解析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• CopyOnWrite：
• 类注释：
• 类属性：
• 添加
• System.arraycopy()
• 获取
• 删除
• 修改
• 批量删除
• 关于迭代：
• 总结：

CopyOnWrite：

是一种策略，表示在使用的时候，将共享内容拷贝一份进行修改，修改完成之后，然后将原容器指向修改后的内容，保证的是最终一致性，因为读写是不同的容器，读的时候不加锁，写的时候加锁。JDK中有CopyOnWriteArrayList和CopyOnWriteArraySet两种已经实现的容器，了解这种思想，我们甚至可以自定义实现别的容器，例如Map，但是为什么没有实现CopyOnWriteHashMap呢，因为已经有了优秀的ConcurrentHashMap。

类注释：

从类注释我们可以得到以下信息：

1. CopyOnWriteArrayList是ArrayList的安全变体。
2. CopyOnWriteArrayList的实现需要数组拷贝有一定的成本，但是通过比其他的方案效率更高。
3. 允许存放各种元素，包括null。
4. 迭代过程中，进行修改不会出现ConcurrentModificationException，因为读写分离。

类属性：

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

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

从上面的代码可以得到以下信息：

1. CopyOnWriteArrayList有一个ReentrantLock实现的锁。
2. 和ArrayList一样，都是通过数组保存数据，但是多个volatile的修饰，用来满足Happen-Before原则。
3. 默认构造函数，将数组初始化为1，没有设置数组大小的构造函数，只能讲数组或者容器传入。

添加

    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        //通过ReentrantLock加锁
        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;
            //如果直接插入到尾部，直接使用copyOf复制一个新的数组，length+1
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + 1);
            else {
                //直接初始化一个新的数组，长度+1
                newElements = new Object[len + 1];
                //复制index前面的部分到新数组
                System.arraycopy(elements, 0, newElements, 0, index);
                //复制index后面的部分到新数组的相应位置
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            //对index位置赋值
            newElements[index] = element;
            //设置到数组中
            setArray(newElements);
        } finally {
            //解锁
            lock.unlock();
        }
    }

这里选择了插入对应下标的方法，如果是插入到尾部，更加简单，可以自行查看。和ArrayList的相关源码差不多，除了加锁解锁，就是ArrayList是直接对原数组进行修改，而CopyOnWriteArrayList选择生成一个新的数组，先将elements的index前面部分复制过去，然后复制后面的部分，然后将element赋值，整体代码非常简单明了。

System.arraycopy()

参数分别为：原数组，复制的起始下标，新数组，复制到新数组原则的起始下标，复制的长度。

获取

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

get()没啥好讲的，就是从数组中获取，可以看到没有通过锁进行加密，读的时候不进行加锁，很有可能出现读到旧数据的情况。

删除

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

步骤如下：

1. 加锁。
2. 通过下标获取oldValue。
3. 如果index为最后一位，直接复制数据，长度-1.
4. 如果index不是最后一位，生成一个新数组，然后先复制index前面的部分，然后index后面的数据整体迁移一位。
5. 解锁。

修改

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

步骤如下：

1. 加锁。
2. 通过参数下标获取oldValue。
3. 如果oldValue和参数element不等，生成一个新数组，然后直接替换index位置的数据，setArray()。
4. 否则setArray()，这一步没看太懂，看了上面的注释，确保volatile的写语义。
5. 返回oldValue，解锁。

批量删除

    public boolean removeAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len != 0) {
                int newlen = 0;
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

步骤如下：

1. 加锁。
2. 当前数组为空，返回false，否则继续。
3. 定义变量newlen，和一个长度为len的空数组，遍历elements数组，判断要删除的collection中是否当前下标值，如果不包含保存到temp数组。
4. 如果newlen != len，复制一个长度为newlen的数组，setArray()，佛足额返回false。
5. 解锁。

从上面我们看到批量删除并不是遍历然后删除每个元素，因为删除元素每次都会有一次数组拷贝，这样会很消耗性能，加锁时间变得很长，影响并发，所以这是批量删除更好的思路，将不需要删除的元素都放到新数组中，而不是挨个删除。

关于迭代：

CopyOnWriteArrayList通过COWIterator实现的迭代器，每次迭代，持有的是原数组的引用，所以修改和新增不会影响到迭代。

总结：

通过上面的源码，我们队CopyOnWriteArrayList有了基本的了解，由于读的时候不加锁，而synchronizedList读写都是加锁的，所以相对来说还是比较推荐使用前者，在并发多线程的场景下。

这篇关于并发和多线程(十七)--CopyOnWriteArrayList源码解析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！