写时复制，CopyOnWriteArrayList源码剖析

1、CopyOnWriteArrayList介绍

CopyOnWriteArrayList是一个线程安全的ArrayList，对其进行的修改操作都是在底层的一个复制的数组（快照）上进行的，也就是使用了写时复制策略。

每个 CopyOnWriteArrayList对象里面有一个array数组对象用来存放具体元素，ReentrantLock独占锁对象用来保证同时只有一个线程对array进行修改。

写时复制，CopyOnWrite容器即写时复制的容器，往一个容器中添加元素的时候，不直接往当前容器Object[]添加，而是先将Object[]进行copy，复制出一个新的容器object[] newElements，然后新的容器Object[] newElements里添加原始，添加元素完后，在将原容器的引用指向新的容器 setArray(newElements)；这样做的好处是可以对copyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不需要添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

2、CopyOnWriteArrayList源码剖析

初始化

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8673264195747942595L;

    /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
}

构造一个Object类型数组

final void setArray(Object[] a) {
    array = a;
}

无参构造函数，在内部创建了一个大小为0的Object数组作为array的初始值。

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();
        if (c.getClass() != ArrayList.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));
}

添加元素

public boolean add(E e) {
    // 获取独占锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取array
        Object[] elements = getArray();
        // 获取array的数组长度，并将其复制到新数组newElements中，数组长度+1，将新添的值添加到新数组中
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        // 使用新数组替换添加前的数组
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

如上代码所示，调用add方法的代码会首先去获取独占锁lock，如果多个线程都调用add方法，则只有一个线程会获取到该锁，其他线程会被阻塞挂起，直到锁被释放。所以一个线程获取到锁后，就保证了该线程添加元素的过程中其他线程不会对array进行修改。

线程获取锁后再执行代码获取数组array，然后复制array到一个新数组，新数组的大小是原来数组的大小加1，所以CopyOnWriteList是一个无界List，并把新增的元素添加到新数组。

然后使用新数组替换原数组，并在返回前释放锁，由于加了锁，所以整个add过程是个原子性操作。再添加元素时，首先复制了一个快照，然后在快照上进行添加，而不是直接在原来数组上进行。

// 返回array数组
final Object[] getArray() {
    return array;
}

获取指定位置元素

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

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

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

由于get操作没有加锁，所以最终拿到的数据不一定是最新的数据。在如上代码中，线程x调用get方法获取指定位置的元素时分两步走，首先获取array数组，然后再通过下标访问指定位置的元素，如果在获取指定位置元素前，有另外一个线程y对数组进行了删除操作，则这时线程x还是只想原始数组array，而此时堆内存的数组已经变为了newarray，所以这就是写时复制策略产生的弱一致性问题。

修改指定元素

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

如上代码，首先获取独占锁lock，从而组织了其他线程对array数组进行修改、添加、删除等操作，然后获取到当前数组，并调用get方法获取指定位置的元素，如果指定位置的元素值和新值不一致则创建新数组并复制元素，然后新数组上修改指定位置的元素值并设置新数组到array。如果指定位置的元素值与新值一样，则为了保证volatile语义，还需要重新设置array，虽然array的内容并没有改变。

删除元素

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

删除元素代码和新增元素的代码类似，首先获取独占锁以保证删除数据期间其他线程不能对array进行修改，然后获取数组中要被删除的元素，并把剩余的元素复制到新数组，之后使用新数组替换原来的数组，最后在返回前释放。

__EOF__

本文作者：Younger
本文链接：https://www.cnblogs.com/youngerwb/p/16309544.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！