CopyOnWriteList源码分析

简介

CopyOnWriteList即写时复制数组，就像它的名字一样，CopyOnWriteList在容器发生变更时，基于当前容器复制出一个新的容器，然后在新容器里变更，最后将旧容器的引用指向新容器，通过与ReentrantLock搭配实现线程安全。而对于容器的读是直接读取当前容器是无锁操作。

成员属性

final transient ReentrantLock lock = new ReentrantLock();
private transient volatile Object[] array;
复制代码

写入操作是一个复制过程，需要互斥。如果没有锁的话，多线程复制不就乱套了。

容器arry用volatile修饰，保证了内存可见性，保证对该容器的读取一定是最后的写入。

ReentrantLock与volatile的配合保证了容器的线程安全。

主要方法

add

以其中一个add方法举例，与ReentrantLock配合，将add元素和旧数组一并复制到一个新数组

public void add(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        if (index > len || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+
                    ", Size: "+len);
        Object[] newElements;
        int numMoved = len - index;
        if (numMoved == 0)
            // 如果是在末尾add，则将元素复制到len+1的新数组里
            newElements = Arrays.copyOf(elements, len + 1);
        else {
            newElements = new Object[len + 1];
            // 如果是在中间插入
            // 旧数组复制到新数组，新旧数组都从0位开始，复制index位
            System.arraycopy(elements, 0, newElements, 0, index);
            // 旧数组复制到新数组，旧数组从index位开始，新数组index+1位，复制numMoved位
            System.arraycopy(elements, index, newElements, index + 1,
                    numMoved);
        }
        newElements[index] = element;
        setArray(newElements);
    } finally {
        lock.unlock();
    }
}
复制代码

remove(int index)

与ReentrantLock配合，旧数组排除remove的元素并复制到一个新数组

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)
            // 如果remove末尾元素，将elements到新数组，长度为len-1
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            Object[] newElements = new Object[len - 1];
            // 如果是在中间remove
            // 旧数组复制到新数组，新旧数组都从0位开始，复制index位
            System.arraycopy(elements, 0, newElements, 0, index);
            // 旧数组复制到新数组，旧数组从index + 1位开始，新数组从index未开始，复制numMoved位
            System.arraycopy(elements, index + 1, newElements, index,
                    numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}
复制代码

get

直接按数组下标返回

private E get(Object[] a, int index) {
    return (E) a[index];
}
public E get(int index) {
    return get(getArray(), index);
}
复制代码

addIfAbsent

这里单独提一下addIfAbsent 和 remove(Object o)等方法，他们返回类型是boolean，也就是说写操作可能会失败。

以addIfAbsent为例

因为addIfAbsent在操作时要先针对传入的对象判断是否已经存在，如果对于当前容器不存在再执行add操作。

但判断“是否存在的操作”是在锁外进行的，所以在锁内操作时，容器可能已经被别的线程修改过，需要多做一层校验。

这里感觉有点乐观锁的意思。

public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
            addIfAbsent(e, snapshot);
}

private boolean addIfAbsent(E e, Object[] snapshot) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) { // 容器已经做过变动
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++) // 判断0至common区间,e是否在current已经存在
                if (current[i] != snapshot[i] && eq(e, current[i]))
                    return false;
            // 判断common至len区间，e是否在current已经存在
            if (indexOf(e, current, common, len) >= 0) 
                return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
复制代码

CopyOnWriteSet

CopyOnWriteSet原理与CopyOnWriteList基本一样。

private final CopyOnWriteArrayList<E> al;

public CopyOnWriteArraySet() {
    al = new CopyOnWriteArrayList<E>();
}
复制代码

CopyOnWriteSet内部为维护了一个CopyOnWriteList对象，核心方法都是CopyOnWriteList方法，只不过对外暴露的接口不一样。

总结

• CopyOnWriteList的读和写有读写分离的意思。CopyOnWriteList适合并发情况下读多写少的场景。
• CopyOnWriteList频繁的操作会造成频繁的复制，所以推荐优先使用addAll、removeAll这种批量操作的方法。
• CopyOnWriteList数据多时，复制操作会占用大量堆内存，会频繁触发GC。
• 由于写入可能会阻塞，而读不会，在多线程下即使某一个线程先写入，另一个线程的读也未必是最新值。

转载于:https://juejin.im/post/5d01bb05f265da1bc5525d7c