【并发容器】3 CopyOnWriteArrayList

3 CopyOnWriteArrayList

Vector和synchronizedList锁粒度大，并发效率低，并且迭代时无法进行编辑。

回顾读写锁的设计规则：允许多个线程同时读取，只允许一个线程同时写入（即写写互斥、读写互斥）。而 CopyOnWriteArrayList设计理念是，读取完全不加锁，并且写入时不会阻塞读取操作，只有写写才需要同步等待。

3.1 一个小案例展示CopyOnWriteArrayList特性

public class CopyOnWriteArrayListIterator {
    public static void main(String[] args) {
        // List<String> list = new ArrayList<>();
        List<String> list = new CopyOnWriteArrayList<>();
        list.add("1");
        list.add("3");
        list.add("5");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(list);
            String next = iterator.next();
            System.out.println(next);
            
            if ("3".equals(next)) {
                list.add("100");
            }
        }
    }
}

[1, 3, 5]
1
[1, 3, 5]
3
[1, 3, 5, 100]
5

1. ArrayList迭代时，如果对列表进行结构修改，会触发Fail-Fast机制，抛出并发修改异常。
2. CopyOnWriteArrayList在迭代时，可以对列表进行修改，但是迭代的结果集仍是修改之前的。
3. 数据取决于迭代器生成的时候，而不会在迭代后更新。

3.2 源码分析

jdk8版本 add操作，使用ReentrantLock加锁，内部复制数组设置元素。

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

jdk13版本改用了synchronized同步代码块，其他变动不大。

final transient Object lock = new Object(); // 锁

public boolean add(E e) {
    synchronized (lock) {
        Object[] es = getArray();
        int len = es.length;
        es = Arrays.copyOf(es, len + 1);
        es[len] = e;
        setArray(es);
        return true;
    }
}

get操作则没有任何加锁操作。

3.3 缺点与适用场景

CopyOnWriteArrayList的缺点：

1. 数据一致性问题：CopyOnWriteArrayList容器只能保证数据的最终一致性，不能保证数据实时一致性。
2. 内存占用问题：CopyOnWrite容器的特点是写操作复制机制，写操作时内存会有两个对象的内存。

适用场景：CopyOnWriteArrayList适用于读操作多，写入操作少的情况。