Java并发编程之CopyOnWriteArrayList

这是我参与11月更文挑战的第21天，活动详情查看：2021最后一次更文挑战

并发包中的并发List只有CopyOnWriteArrayList,这是一个线程安全的ArrayList,对其进行的修改操作都是在底层的一个复制的数组上进行的，使用了写时复制的策略。每个CopyOnWriteArrayList对象里面有一个array数组对象用来存放具体元素，RenntrantLock独占锁用来保证同时只有一个线程对array进行修改。

下面我们来看一下CopyOnWriteArrayList主要方法的源码

构造函数

无参构造函数

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
复制代码

入参为集合，将集合里面的元素复制到本list

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

复制代码

创建一个list，其内部元素是入参toCopyIn的副本

public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
复制代码

添加元素

CopyOnWriteArrayList中用来添加元素的函数有add(E e)add(int index, Element) addIfAbsent(E e) addAllAbsent(Collection<? extents E> c>) 等，他们的原理类似，本文中以add(E e)为例来讲解。

public boolean add(E e) {
    final ReentrantLock lock = this.lock; //代码1
    lock.lock();
    try {
        Object[] elements = getArray(); //代码2
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e; //代码3
        setArray(newElements);
        return true;//代码4
    } finally {
    //代码5
        lock.unlock();
    }
}
复制代码

在如上代码中，调用add方法的线程会首先去获取独占锁(ReentrantLock)，多个线程都调用add时，只有一个线程会获取到锁，其他线程会被阻塞挂起知道锁被释放。所以一个线程获取到锁后就保证了在线程添加元素的过程期间其他线程不会对array进行修改。

线程先在代码1处获取到锁后，会在代码2执行getArray()获取数组，然后执行Arrays.copyOf复制数组（新数组的大小是原数组大小+1）。然后在代码3处，将新增加的元素添加到新数组，并在代码4处替换原数组。最后，在代码5出处释放资源。

获取指定位置的元素

使用E get(int index)获取下标为index的元素，如果元素不存在则抛出IndexOutOfBoundsException异常。

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

final Object[] getArray() {
    return array;
}

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

复制代码

如上代码中，当线程X调用get方法获取指定位置的元素时，首先获取array数组，然后通过下标index访问数组获取对应位置元素。

但是如果当线程X获取到数组还未去获取数组元素值时，另一个线程Y执行了删除元素的操作。这是时候线程X获取到的值就不是正确的了。这就是写时复制策略产生的弱一致性问题。

修改指定元素

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();
    }
}
复制代码

使用E set(int index,E element) 修改list中指定元素的值，如果指定位置的元素不存在则抛出IndexOutOfBoundException异常。如上代码中，首先获取了独占锁，从而阻止了其他线程对array数组进行修改，然后获取当前数组，并调用get方法获取指定位置元素。如果指定位置的元素值与心智不一样则创建新数组修改元素值，并替换旧数组。如果新、旧值一样也需要重新替换数组，需要这样来保证volatile语义。

删除元素

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();
    }
}
复制代码

如上代码中，主要是看删除的元素是否位于最后。如果要删除的元素位于最后，直接使用Arrays.copyOf()取出前面的n-1个数据，如果不是则分成两部分来复制。首先计算后半部分的长度numMoved，然后使用System.Arraycopy()复制元素到新数组。