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。
• 因爲寫入可能會阻塞，而讀不會，在多線程下即便某一個線程先寫入，另外一個線程的讀也未必是最新值。