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

三、CopyOnWriteArrayList的优点

实现对CopyOnWrite集合容器写入操作时的线程安全，但同时并不影响进行并发的读取操作。所以CopyOnWrite容器也是一种读写分离的思想，CopyOnWriteArrayList相当于线程安全的ArrayList，内部存储结构采用Object[]数组，线程安全使用ReentrantLock实现，允许多个线程并发读取，但只能有一个线程写入。

四、CopyOnWriteArrayList的源码分析

本篇文章我们以CopyOnWriteArrayList中的几个方法的源码进行深入了解并发集合是如何实现的:

构造方法：


public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
 
    //定义ReentrantLock 
    final transient ReentrantLock lock = new ReentrantLock();
 
    private transient volatile Object[] array;
 
    //得到数组
    final Object[] getArray() {
        return array;
    }
 
    //返回新数组为传入的数组
    final void setArray(Object[] a) {
        array = a;
    }
 
 
    //无参构造方法：默认长度为0
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
 
    //有参构造方法：传入一个Collection类型的集合
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        //判断集合的类型是否与CopyOnWriteArrayList类型一致
        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);
    }
}

add（）：

添加新元素至集合时，会将当前数组Copy复制新数组，并将新元素添加至新数组，最后替换原数组。执行过程中，使用ReentrantLock加锁，保证线程安全，避免多个线程复制数组。


//添加
    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);
          //将添加元素存入新数组末尾
            newElements[len] = e;
            //返回新数组
            setArray(newElements);
            return true;
        } finally {
            //释放锁
            lock.unlock();
        }
    }

set（int index, E element）：

根据下标修改元素值时，首先判断原值与新值是否相等，相等的时候，直接指向原数组，如果值不相等，复制数组，修改新数组中的值，重新指向到新数组


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

remove(int index)：

删除指定下标元素。根据指定下标，从原数组中，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);
            int numMoved = len - index - 1;
			// 判断下标是否是尾下标
            if (numMoved == 0)
				// 直接复制原数组长度-1
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                Object[] newElements = new Object[len - 1];
				// 从0开始复制index个元素
                System.arraycopy(elements, 0, newElements, 0, index);
				 // 原数组从index+1下标开始，新数组从index开始，复制numMoved个元素
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
			// 解锁
            lock.unlock();
        }
    }

addAll(int index, Collection<? extends E> c)：

在原数组的指定位置添加新集合


 // 在原集合指定位置添加新集合
    public boolean addAll(int index, Collection<? extends E> c) {
		// 指定集合转化成数组
        Object[] cs = c.toArray();
		// 加锁
        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);
            // 判断新集合是否为空
			if (cs.length == 0)
                return false;
            int numMoved = len - index;
            Object[] newElements;
			// 判断指定下标是否是尾下标
            if (numMoved == 0)
				// 复制新数组并且长度是原数组长度+新数组长度
                newElements = Arrays.copyOf(elements, len + cs.length);
            else {
                newElements = new Object[len + cs.length];
				// 从0开始复制index个元素
				System.arraycopy(elements, 0, newElements, 0, index);
				// 从原集合从index下标开始，结果集合从index+新数组长度开始复制numMoved个元素
                System.arraycopy(elements, index,
                                 newElements, index + cs.length,
                                 numMoved);
            }
			// 新数组从0开始，结果数组从index开始，复制新数组长度
            System.arraycopy(cs, 0, newElements, index, cs.length);
			// 设置数组为结果数组
            setArray(newElements);
            return true;
        } finally {
			// 解锁
            lock.unlock();
        }
    }

retainAll(Collection<?> c)：

获取集合的交集，并将原数组替换成交集集合


// 判断集合间是否有交集并把原集合更新成交集
    public boolean retainAll(Collection<?> c) {
		// 如果集合为空，抛出NullPointerException()异常
        if (c == null) throw new NullPointerException();
		// 加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
			// 获取原数组
            Object[] elements = getArray();
			// 获取原数组长度
            int len = elements.length;
			// 判断长度是否为0
            if (len != 0) {
                // temp array holds those elements we know we want to keep
                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();
        }
    }

五、小结

当我们需要在线程不安全场景下使用 List 时，建议使用 CopyOnWriteArrayList，CopyOnWriteArrayList 通过锁 + 数组拷贝 + volatile 之间的相互配合，实现了 List 的线程安全。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/859967