写时复制（Copy On Write，COW）是一种计算机程序设计思想，其核心原理是：如果有多个访问器（Accessor）访问一个资源（如内存或者磁盘上的数据存储），它们会共同获取相同的指针指向相同的资源，只要有一个修改器（Mutator）需要修改该资源，系统就会复制一份专用副本（Private Copy）给该修改器，而其他访问器所见到的最初资源仍然保持不变，修改的过程对其他访问器都是透明的（Transparently）。COW 的主要优点是如果没有修改器去修改资源，就不会创建副本，因此多个访问器可以共享同一份资源。

CopyOnWriteArrayList 的基本使用

public class CopyOnWriteArrayList_Test {
    public static void main(String[] args) throws InterruptedException {
        // ArrayList
        List<String> strings = Arrays.asList("a", "b", "c");
        // Collections.SynchronizedRandomAccessList
        List<String> list = Collections.synchronizedList(strings);
        ConcurrentTarget target = new ConcurrentTarget(list);
        for (int i = 0; i < 10; i++) {
            new Thread(target, "线程" + i).start();
        }
        Thread.sleep(2000);
    }
    private static class ConcurrentTarget implements Runnable {
        private List<String> targetList = null;
        private ConcurrentTarget(List<String> targetList) {
            this.targetList = targetList;
        }
        @Override
        public void run() {
            Iterator<String> iterator = targetList.iterator();
            while (iterator.hasNext()) {
                String name = Thread.currentThread().getName();
                System.out.println("当前线程: " + name);
                targetList.add(name);
            }
        }
    }
}

以上代码会报 java.lang.UnsupportedOperationException 异常：

Exception in thread “线程3” java.lang.UnsupportedOperationException at java.util.AbstractList.add(AbstractList.java:148) at java.util.AbstractList.add(AbstractList.java:108) at java.util.Collections$SynchronizedCollection.add(Collections.java:2035) at com.bujian.concurrent.juc.CopyOnWriteArrayList_Test$ConcurrentTarget.run(CopyOnWriteArrayList_Test.java:43) at java.lang.Thread.run(Thread.java:748)

这是为啥呢？因为 Arrays.asList(T …t) 方法返回的是 ArrayList，这个 ArrayList 是 Arrays 的一个内部类，并没有实现 add(int index, E element)，因此调用的是 AbstractList#add(int index, E element)：

    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

解决这个问题的办法之一就是使用 CopyOnWriteArrayList：

    public static void main(String[] args) throws InterruptedException {
        List<String> strings = Arrays.asList("a", "b", "c");
        CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>(strings);
        ConcurrentTarget target = new ConcurrentTarget(copyOnWriteArrayList);
        for (int i = 0; i < 10; i++) {
            new Thread(target, "线程" + i).start();
        }
        Thread.sleep(2000);
    }

CopyOnWriteList 的原理

CopyOnWrite（写时复制）就是在修改器对一块内存进行修改时，不直接在原有内存块上进行写操作，而是将内存复制一份，在新的内存中进行写操作，写完之后，再将原来的指针（或者引用）指向新的内存，原来的内存被回收。

CopyOnWriteArrayList是写时复制思想的一种典型实现，其含有一个指向操作内存的内部指针 array，而可变操作（add、set 等）是在 array 数组的副本上进行的。当元素需要被修改或者增加时，并不直接在 array 指向的原有数组上操作，而是首先对 array 进行一次复制，将修改的内容写入复制的副本中。写完之后，再将内部指针 array 指向新的副本，这样就可以确保修改操作不会影响访问器的读取操作。

图 - CopyOnWriteArrayList 的原理

CopyOnWriteList 的核心成员如下：

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    /** 对所有的修改进行保护的锁 */
    final transient ReentrantLock lock = new ReentrantLock();
    /** 内部数组, 通过 getArray/setArray 方法进行访问 */
    private transient volatile Object[] array;
    final Object[] getArray() {
        return array;
    }
    /**
     * Sets the array.
     */
    final void setArray(Object[] a) {
        array = a;
    }
}

CopyOnWriteList 读取数据

数据的读取操作没有任何同步控制和锁操作，理由是内部数组 array 不会发生修改，只会被另一个 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;
    }

CopyOnWriteList 写入数据

CopyOnWriteArrayList 的写入操作 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;
            // 将新数组设置给array变量
            setArray(newElements);
            return true;
        } finally {
            // 加锁
            lock.unlock();
        }
    }

从add() 操作可以看出，在每次进行添加操作时，CopyOnWriteArrayList 底层都是重新复制一份数组。既然每次添加元素的时候都会重新复制一份新的数组，那就带来了一个问题，就是增加了内存的开销，如果容器的写操作比较频繁，那么其开销就比较大。所以，在实际应用的时候，CopyOnWriteArrayList 并不适合进行添加操作。但是在并发场景下，迭代操作比较频繁，CopyOnWriteArrayList 就是一个不错的选择。

CopyOnWriteList 迭代器

CopyOnWriteArray 有自己的迭代器，该迭代器不会检查修改状态，也无须检查状态。因为被迭代的 array 数组可以说是只读的，不会有其他线程能够修改它。

    static final class COWIterator<E> implements ListIterator<E> {
        /** 内部数组array的快照 */
        private final Object[] snapshot;
        /**  后续调用 next 将返回的元素索引 */
        private int cursor;
        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }
        // 当前索引是否大于数组长度
        public boolean hasNext() {
            return cursor < snapshot.length;
        }
        public boolean hasPrevious() {
            return cursor > 0;
        }
        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            // 数组操作，取下一个索引位置的元素
            return (E) snapshot[cursor++];
        }
        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            return (E) snapshot[--cursor];
        }
        public int nextIndex() {
            return cursor;
        }
        public int previousIndex() {
            return cursor-1;
        }
        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code remove}
         *         is not supported by this iterator.
         */
        public void remove() {
            throw new UnsupportedOperationException();
        }
        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code set}
         *         is not supported by this iterator.
         */
        public void set(E e) {
            throw new UnsupportedOperationException();
        }
        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code add}
         *         is not supported by this iterator.
         */
        public void add(E e) {
            throw new UnsupportedOperationException();
        }
        // 使用Consumer的accept()方法对每个元素进行操作
        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] elements = snapshot;
            final int size = elements.length;
            for (int i = cursor; i < size; i++) {
                @SuppressWarnings("unchecked") E e = (E) elements[i];
                action.accept(e);
            }
            cursor = size;
        }
    }

调用 iterator() 方法将返回 COWIterator 对象：

    public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }

注意：COWIterator 并没有实现 remove()、set(E e)、add(E e) 这些方法，调用这些方法将抛出 UnsupportedOperationException 异常。

Java 系列学习笔记

Java并发编程-CopyOnWriteArrayList

CopyOnWriteArrayList 的基本使用

CopyOnWriteList 的原理

CopyOnWriteList 读取数据

CopyOnWriteList 写入数据

CopyOnWriteList 迭代器