Java 經典面試題：聊一聊 JUC 下的 CopyOnWriteArrayList

ArrayList 是我們常用的工具類之一，但是在多線程的情況下，ArrayList 作爲共享變量時，並不是線程安全的。主要有以下兩個原因：

• 1、 ArrayList 自身的 elementData、size、modCount 在進行操作的時候，都沒有加鎖；
• 2、這些變量沒有被 volatile 修飾，在多線程的情況下，對這些變量操作可能會出現值被覆蓋的情況；

如果我們想在多線程情況下使用 ArrayList 怎麼辦？有以下幾種辦法：

• 使用 Collections.SynchronizedList ；
• 使用 JUC 下的 CopyOnWriteArrayList；

先來看看 SynchronizedLis，Collections 其實就是對 ArrayList 進行了一個加鎖包裝，這個從源碼中可以看出;

...部分源碼，完整源碼請查看 JDK 源碼...
public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
    synchronized (mutex) {return list.remove(index);}
}

對於 Collections.SynchronizedList 比較簡單，就是鎖包裝了一下，就不多說了~

CopyOnWriteArrayList 也是 JUC 下面的一個併發容器類。不知道你發現沒有，但凡你常用的集合類，在 JUC 下基本上都可以找到一個併發類，比如 hashMap 有對應的 ConcurrentHashMap。

CopyOnWriteArrayList 跟 ArrayList 在整體架構上並沒有什麼區別，底層都是基於數組實現的。不同的地方大概有兩點：

• 底層數組被 volatile 關鍵字修飾；
• 對數組進行數據變更時加鎖；

CopyOnWriteArrayList 的加鎖操作跟 Collections.SynchronizedList 簡單的加鎖還不一樣，CopyOnWriteArrayList 中的加鎖過程還是非常值得學習的。CopyOnWriteArrayList 的加鎖過程，大概可以概括爲以下四步：

• 1、加鎖；
• 2、從原數組中拷貝出新數組；
• 3、在新數組上進行操作，並把新數組賦值給數組容器；
• 4、解鎖；

結合源碼來深入瞭解 CopyOnWriteArrayList 的併發實現，我們選擇 ArrayList 最簡單的將元素新增數組尾部的操作來分析實現過程，源碼如下：

/**
 * Appends the specified element to the end of this list.
 *
 * @param e element to be appended to this list
 * @return {@code true} (as specified by {@link Collection#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;
        // 變更底層數組的引用
        setArray(newElements);
        return true;
    } finally {
	    // 解鎖
        lock.unlock();
    }
}

CopyOnWriteArrayList 就是通過加鎖來說實現容器安全的，可能你會有疑問，爲什麼引入一個新數組，數組的拷貝還是消耗時間的，直接在原數組上操作不就好了嗎？。主要原因有以下兩點：

• volatile 關鍵字修飾的是數組，如果我們簡單的在原來數組上修改其中某幾個元素的值，是無法觸發可見性的，我們必須通過修改數組的內存地址才行，也就說要對數組進行重新賦值才行。
• 在新的數組上進行拷貝，對老數組沒有任何影響，只有新數組完全拷貝完成之後，外部才能訪問到，降低了在賦值過程中，老數組數據變動的影響。比如經典的 ConcurrentModificationException 異常問題。

其他的新增方法就自己去查看源碼了，相差不多，基本上是一樣的。對數組的刪除跟新增都是差不多，不同的地方是在刪除了時候，賦值給新數組時會出現不同的選擇策略。我把源碼貼上：

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

CopyOnWriteArrayList 還有其他的方法，在這裏我就不過多介紹了。根據你們自己的疑問去扒一扒 CopyOnWriteArrayList 的源碼就知道了，總體來說 CopyOnWriteArrayList 並不難，甚至感覺比 ArrayList 要簡單。

總結一下：CopyOnWriteArrayList 是安全的併發容器，有以下兩個特點：

• 1、對數組的寫操作加鎖，讀操作不加鎖；
• 2、通過加鎖 + 數組拷貝+ volatile 來保證線程安全；

歡迎關注公衆號【互聯網平頭哥】，一起成長，一起進步~。