CopyOnWriteArrayList源码详解

CopyOnWriteArrayList源码详解

最近在一个代码优化中使用到CopyOnWriteArrayList，想起这个java容器知道使用特性是读写分离，在每次写入时都复制一个新的list进行操作，但是没有具体的看过其源码细节，于是写一篇文章来记载下。

demo演示

---

首先写一个简单的程序演示一下，如下：

CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CountDownLatch countDownLatch = new CountDownLatch(9);
        for (int i = 0; i < 9; i++) {
            executorService.execute(() -> {
                Random random = new Random(System.currentTimeMillis());
                list.add(random.nextInt());
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(list.toString());

这里输出就随意了，就不贴出输出结果了，直接看CopyOnWriteArrayList源码。

CopyOnWriteArrayList源码

---

首先看下CopyOnWriteArrayList的构造方法，进入构造方法。

/**
     * Creates an empty list.
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
/**
     * Sets the array.
     */
    final void setArray(Object[] a) {
        array = a;
    }

构造方法没有什么特别的地方，就是初始化一个空的Object数组。

接下来看add方法，add方法基本就是其关键所在，在add方法中实现数组复制写入，源码如下：

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

add方法比较简单，这里首先的操作就是对当前方法加锁。

final ReentrantLock lock = this.lock;
lock.lock();

然后获取当前数组，然后再进行数组的copy和新值的插入。

int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;

最后将array重新set入原数组中，这个setArray方法可能是进行两个数组合并工作，并首先进行了加锁操作，可以一起看一下。

/**
     * Sets the array.
     */
    final void setArray(Object[] a) {
        array = a;
    }

比较简单，就是进行了array的赋值，那么能够肯定的就是remove操作必定也是进行的加锁操作，这样除了读取以外，其他操作都是需要进行锁的写入和删除的。

在新值添加完成后，最后进行unlock操作。

lock.unlock();

这里想必除了读取以外，其他的操作都是需要进行加锁操作的，可以简单看下get方法。

/**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return get(getArray(), index);
    }
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

操作比较简单，就是从array中读取值。

接下来看remove。

/**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the list.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    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();
        }
    }

remove方法开头与add相同，也是进行加锁操作，这样add、set、remove操作在同时就只有一个操作可以进行，同时也就避免了写入脏数据问题。

接下来的操作就比较简单了，进行了一个简单的数组的copy、value的替换和数组的重新赋值回原数组。

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

这里就不再对CopyOnWriteArrayList的set或者诸如toString()、sort方法进行讲解了，原理都类似，这里看一个比较有意思的方法，为subList(int fromIndex, int toIndex),获取数组中的一段范围。

/**
     * Returns a view of the portion of this list between
     * {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
     * The returned list is backed by this list, so changes in the
     * returned list are reflected in this list.
     *
     * 
The semantics of the list returned by this method become
     * undefined if the backing list (i.e., this list) is modified in
     * any way other than via the returned list.
     *
     * @param fromIndex low endpoint (inclusive) of the subList
     * @param toIndex high endpoint (exclusive) of the subList
     * @return a view of the specified range within this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public List subList(int fromIndex, int toIndex) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (fromIndex < 0 || toIndex > len || fromIndex > toIndex)
                throw new IndexOutOfBoundsException();
            return new COWSubList(this, fromIndex, toIndex);
        } finally {
            lock.unlock();
        }
    }

这个方法直接返回了一个CowList对象，而不是一个list列表，可以看看CowList类。

private static class COWSubList
        extends AbstractList
        implements RandomAccess
    {
        private final CopyOnWriteArrayList l;
        private final int offset;
        private int size;
        private Object[] expectedArray;

        // only call this holding l's lock
        COWSubList(CopyOnWriteArrayList list,
                   int fromIndex, int toIndex) {
            l = list;
            expectedArray = l.getArray();
            offset = fromIndex;
            size = toIndex - fromIndex;
        }

        // only call this holding l's lock
        private void checkForComodification() {
            
        }

        // only call this holding l's lock
        private void rangeCheck(int index) {
            
        }

        public E set(int index, E element) {
           
        }

        public E get(int index) {
            
        }

        public int size() {
            
        }

        public void add(int index, E element) {
            
        }
    }

COWSubList方法只是有offset、size等属性，并不是有真正的list中的值，并有list的相关的方法，那么在源list发生变化时，这个CowSubList也会发生相应的value的变化，这个在一些特殊的场景下确实比较有作用。

CopyOnWriteArrayList还有一些其他的特殊用法，例如返回listIterator之类的，这些都没有特别出奇的地方，就不详细讲述了。

CopyOnWriteArrayList用法除了在set、add、remove操作与别的list对应的方法不同外，其他基本倒是类似，因此CopyOnWriteArrayList就讲到这里了。