怎么理解Java中JUC下的CopyOnWriteArrayList

這篇文章主要講解了“怎么理解Java中JUC下的CopyOnWriteArrayList”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“怎么理解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();
    }
}

感謝各位的閱讀，以上就是“怎么理解Java中JUC下的CopyOnWriteArrayList”的內容了，經過本文的學習后，相信大家對怎么理解Java中JUC下的CopyOnWriteArrayList這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！