摘要：僅僅當有多個線程同時進行寫操作時，才會進行同步。可以看到，上述方法返回一個迭代器對象，的迭代是在舊數組上進行的，當創建迭代器的那一刻就確定了，所以迭代過程中不會拋出并發修改異常。另外，迭代器對象也不支持修改方法，全部會拋出異常。

本文首發于一世流云專欄：https://segmentfault.com/blog...

ArrayList是一種“列表”數據機構，其底層是通過數組來實現元素的隨機訪問。JDK1.5之前，如果想要在并發環境下使用“列表”，一般有以下3種方式：

使用Vector類

使用Collections.synchronizedList返回一個同步代理類；

自己實現ArrayList的子類，并進行同步/加鎖。

前兩種方式都相當于加了一把“全局鎖”，訪問任何方法都需要首先獲取鎖。第3種方式，需要自己實現，復雜度較高。

JDK1.5時，隨著J.U.C引入了一個新的集合工具類——CopyOnWriteArrayList：

大多數業務場景都是一種“讀多寫少”的情形，CopyOnWriteArrayList就是為適應這種場景而誕生的。

CopyOnWriteArrayList，運用了一種“寫時復制”的思想。通俗的理解就是當我們需要修改（增/刪/改）列表中的元素時，不直接進行修改，而是先將列表Copy，然后在新的副本上進行修改，修改完成之后，再將引用從原列表指向新列表。

這樣做的好處是讀/寫是不會沖突的，可以并發進行，讀操作還是在原列表，寫操作在新列表。僅僅當有多個線程同時進行寫操作時，才會進行同步。

CopyOnWriteArrayList的字段很簡單：

public class CopyOnWriteArrayList
    implements List, RandomAccess, Cloneable, java.io.Serializable {

    /**
     * 排它鎖, 用于同步修改操作
     */
    final transient ReentrantLock lock = new ReentrantLock();

    /**
     * 內部數組
     */
    private transient volatile Object[] array;
}

其中，lock用于對修改操作進行同步，array就是內部實際保存數據的數組。

構造器定義

CopyOnWriteArrayList提供了三種不同的構造器，這三種構造器最終都是創建一個數組，并通過setArray方法賦給array字段：

/**
 * 空構造器.
 */
public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
?
僅僅是設置一個了大小為0的數組，并賦給字段array：
final void setArray(Object[] a) {
    array = a;
}

/**
 * 根據已有集合創建
 */
public CopyOnWriteArrayList(Collection 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);
}

/**
 * 根據已有數組創建.
 *
 * @param toCopyIn the array (a copy of this array is used as the
 *                 internal array)
 * @throws NullPointerException if the specified array is null
 */
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

查詢——get方法

public E get(int index) {
    return get(getArray(), index);
}

private E get(Object[] a, int index) {
    return (E) a[index];
}

可以看到，get方法并沒有加鎖，直接返回了內部數組對應索引位置的值：array[index]

添加——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);              // 內部array引用指向新數組
        return true;
    } finally {
        lock.unlock();
    }
}

add方法首先會進行加鎖，保證只有一個線程能進行修改；然后會創建一個新數組（大小為n+1），并將原數組的值復制到新數組，新元素插入到新數組的最后；最后，將字段array指向新數組。

上圖中，ThreadB對Array的修改由于是在新數組上進行的，所以并不會對ThreadA的讀操作產生影響。

刪除——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)                  // index位置剛好是最后一個元素
            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();
    }
}

刪除方法和插入一樣，都需要先加鎖（所有涉及修改元素的方法都需要先加鎖，寫-寫不能并發），然后構建新數組，復制舊數組元素至新數組，最后將array指向新數組。

其它統計方法

public int size() {
    return getArray().length;
}

public boolean isEmpty() {
    return size() == 0;
}

迭代

CopyOnWriteArrayList對元素進行迭代時，僅僅返回一個當前內部數組的快照，也就是說，如果此時有其它線程正在修改元素，并不會在迭代中反映出來，因為修改都是在新數組中進行的。

public Iterator iterator() {
    return new COWIterator(getArray(), 0);
}
?
static final class COWIterator implements ListIterator {
    /**
     * 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 E next() {
        if (!hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }
    
    // ...
}

可以看到，上述iterator方法返回一個迭代器對象——COWIterator，COWIterator的迭代是在舊數組上進行的，當創建迭代器的那一刻就確定了，所以迭代過程中不會拋出并發修改異常——ConcurrentModificationException。

另外，迭代器對象也不支持修改方法，全部會拋出UnsupportedOperationException異常。

CopyOnWriteArrayList的思想和實現整體上還是比較簡單，它適用于處理“讀多寫少”的并發場景。通過上述對CopyOnWriteArrayList的分析，讀者也應該可以發現該類存在的一些問題：

1. 內存的使用
由于CopyOnWriteArrayList使用了“寫時復制”，所以在進行寫操作的時候，內存里會同時存在兩個array數組，如果數組內存占用的太大，那么可能會造成頻繁GC,所以CopyOnWriteArrayList并不適合大數據量的場景。

2. 數據一致性
CopyOnWriteArrayList只能保證數據的最終一致性，不能保證數據的實時一致性——讀操作讀到的數據只是一份快照。所以如果希望寫入的數據可以立刻被讀到，那CopyOnWriteArrayList并不適合。