CopyOnWriteArrayList源码解析

我们肯定都使用过ArrayList,但是多线程或并发环境下,ArrayList作为共享变量被访问,是线程不安全的。我们可以选择自己加锁或Collections.synchronizedList()去实现一个线程安全的容器。除此之外,我们还可以使用今天要学习的CopyOnWriteArrayList。

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

参数分别为:原数组,复制的起始下标,新数组,复制到新数组原则的起始下标,复制的长度。
CopyOnWriteArrayList源码解析_第1张图片

获取

	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读写都是加锁的,所以相对来说还是比较推荐使用前者,在并发多线程的场景下。

你可能感兴趣的:(并发,多线程)