剖析 CopyOnWriteArrayList

原文連接：https://www.changxuan.top/?p=1252

---

CopyOnWriteArrayList 是 JUC 中惟一一個支持併發的 List。

CopyOnWriteArrayList 的修改操做都是在底層的一個複製的數組上進行，即寫時複製策略，從而實現了線程安全。其實原理和數據庫的讀寫分離十分類似。

基本構成

底層使用數組 private transient volatile Object[] array; 來存儲元素，使用 ReentrantLock 獨佔鎖保證相關操做的安全性。

構造函數

public CopyOnWriteArrayList() {
        setArray(new Object[0]);
}
// 將集合 c 內的元素複製到 list 中
public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
}
// 建立一個內部元素是 toCopyIn 副本的 list
public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

添加元素

CopyOnWriteArrayList 中與添加元素相關的方法有如下幾種：

• add(E e)
• add(int index, E element)
• addAll(Collection<? extends E> c)
• addAll(int index, Collection<? extends E> c)
• addIfAbsent(E e)
• addAllAbsent(Collection<? extends E> c)

鑑於原理基本類似，下面只分析 add(E e) 和 addIfAbsent(E e) 方法作爲例子。

add(E e)

源碼

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 方法的線程首先會去嘗試獲取獨佔鎖，成功獲取的線程會繼續執行後續添加元素邏輯，而未獲取獨佔鎖的線程在沒有異常的狀況下則會阻塞掛起。等待獨佔鎖被釋放後，再次嘗試獲取。（ps. 在 CopyOnWriteArrayList 中使用的是 ReentrantLock 的非公平鎖模式）

這樣就能保證，同一時間只有一個線程進行添加元素。

addIfAbsent(E e)

源碼

public boolean addIfAbsent(E e) {
    // 獲取當前數組
    Object[] snapshot = getArray();
    // 調用 indexOf 判斷元素是否已存在 （遍歷）
    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++)
                if (current[i] != snapshot[i] && eq(e, current[i]))
                    return false;
            if (indexOf(e, current, common, len) >= 0)
                    return false;
        }
        // 與 add 方法的邏輯相同
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

若是當前數組中不存在元素 e，addIfAbsent 則會將 e 添加至數組中返回 true；若是當前數組中存在待添加元素，則會返回 false。

在 addIfAbsent 方法中爲了提升性能，設計者把判斷「當前數組是否存在待添加元素」和「添加元素」的操做分開了。因爲前一個操做沒必要要獲取獨佔鎖，在遇到每次待添加的元素都已經存在於數組的狀況時能夠高效的返回 false 。

由於上面提到的兩步操做是非原子性的，因此再第二步操做中還須要再次進行確認以前用來判斷不存在元素 e 的數組是否被「掉包」了。若是被「掉包」，那麼也不要「嫌棄」。就須要再判斷一下「掉包」後的數組還能不能接着用。若是不能用直接返回 false，若是發現能用就繼續向下執行，成功後返回 true 。

這種設計思路，在本身的業務系統中仍是比較值的借鑑的。固然上述場景下「壞」的設計，就是會先嚐試獲取獨佔鎖，在獲取獨佔鎖後再進行「判斷元素是否存在和決定是否添加元素的操做」。這樣則會致使大大增長線程阻塞掛起概率。相信大多數同窗仍是能寫出漂亮的代碼的，不至於犯這種小錯誤。

獲取元素

獲取元素一共涉及到三個方法，源碼以下：

public E get(int index) {
    return get(getArray(), index);
}
// 步驟一
final Object[] getArray() {
    return array;
}
// 步驟二
private E get(Object[] a, int index) {
    return (E) a[index];
}

咱們看到獲取元素的操做，全程沒有加鎖。而且獲取元素是由兩步操做組合而成的，一獲取當前數組，二從當前數據中取出所指定的下標位置的元素。一旦在這兩步操做之間，有其它線程更改了 index 下標位置的元素。此時，獲取元素的線程所使用的數組則是被廢棄掉的，它接收到的值也不是最新的值。這是寫時複製策略產生的弱一致性問題。

修改元素

可使用 set(int index, E element) 方法修改指定位置的元素。

源碼

public E set(int index, E element) {
    // 獲取獨佔鎖
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 獲取當前數組
        Object[] elements = getArray();
        // 獲取要修改位置的元素
        E oldValue = get(elements, index);
        // 新值與老值是否同樣
        if (oldValue != element) {
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len);
            newElements[index] = element;
            setArray(newElements);
        } else {
            // Not quite a no-op; ensures volatile write semantics
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

能夠看到，在代碼中並無顯示的判斷 index 是否合法，若是不合法則會拋出 IndexOutOfBoundsException 異常。

主要邏輯也是先嚐試獲取獨佔鎖，符合條件則進行修改。須要注意的一點是，若是指定索引處的元素值與新值相等，也會調用 setArray(Object[] a) 一次方法，這主要是爲了保證 volatile 語義。（線程在寫入 volatile 變量時，不會把值緩存在寄存器或者其它地方，而是會把值刷回到主內存，確保內存可見性）

刪除元素

刪除元素的方法包括：

• E remove(int index)
• boolean remove(Object o)
• boolean removeAll(Collection<?> c)

咱們來看下 remove(int index) 的實現，
源碼

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

其實代碼邏輯很清楚，獲取鎖後根據狀況複製老數組中的未刪除數據到新數組便可。

迭代器

不知道你們有沒有在遍歷 ArrayList 變量的過程當中想沒想過刪除其中的某個元素？反正我曾經這麼寫過，而後就出現了問題 ... 後來使用了 ArrayList 的迭代器以後就沒有錯誤了。

在 CopyOnWriteArrayList 中也有迭代器，可是也存在着弱一致性問題
源碼

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

static final class COWIterator<E> implements ListIterator<E> {
    /** Snapshot of the array 數組的快照版本 */
    private final Object[] snapshot;
    /** Index of element to be returned by subsequent call to 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;
    }
    // 獲取元素
    public E next() {
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

   ... ...

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor-1;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }

    public void set(E e) {
        throw new UnsupportedOperationException();
    }
    
    public void add(E e) {
        throw new UnsupportedOperationException();
    }

    ... ...
}

能夠看到，CopyOnWriteArrayList 的迭代器並不支持 remove 操做。在調用 iterator() 方法時獲取了一份當前數組的快照，若是在遍歷期間並無其它線程對數據作更改操做就不會出現一致性的問題。一旦有其它線程對數據更改後，將 CopyOnWriteArrayList 中的數組更改成了新數組，此時迭代器所持有的數據就至關於快照了，同時也出現了弱一致性問題。

拓展延申

還記得剛剛提到的 addIfAbsent 方法嗎？看到它你有沒有聯想到什麼東西呢？集合 set?

對的，經過 addIfAbsent 方法也能實現集合的功能，CopyOnWriteArraySet 的底層就是使用 CopyOnWriteArrayList 實現的。(PS. HasSet 的底層依賴 HashMap 。)