阿裡面試官沒想到，一個CopyOnWriteArrayList，我都能跟他吹半小時(1)

阿裡面試官沒想到，一個Java 的 CopyOnWriteArrayList，我都能跟他吹半小時，驚呆了。

先看再點贊，給自己一點思考的時間，微信搜尋【沉默王二】關注這個靠才華苟且的程式員。

本文 GitHub github.com/itwanger 已收錄，裡面還有一線大廠整理的面試題，以及我的系列文章。

hello，同學們，大家好，我是沉默王二，在我為數不多的面試經曆中，有一位姓馬的面試官令我印象深刻，九年過去了，我還能記得他為數不多的發量。

老馬：“兄弟，ArrayList 是線程安全的嗎？”

王二：“不是啊。”

老馬：“那有沒有線程安全的 List？”

王二：“有啊，Vector。”

老馬：“還有别的嗎？”

王二：“Vector 不就夠用了嗎？”

老馬看了一下左手腕上的表，說道：“今天差不多就到這裡吧，你回去等通知。”

（不是，我特麼不是剛進來，就回答了三個問題而已，就到這了？）

現在回想起來當時一臉懵逼的樣子，臉上情不自禁地泛起了紅暈，老馬的意思是讓我說說 Java 的 CopyOnWriteArrayList，可惜我當時幾乎沒怎麼用過這個類，也不知道它就是個線程安全的 List，慚愧啊慚愧。

（地上有坑嗎？我想跳進去。）

真正的勇士敢于直面過去的慘淡，經過這麼多年的努力，我的技術功底已經大有長進了，是時候輸出一波傷害了。希望這篇文章能夠給不太了解 CopyOnWriteArrayList 的同學一點點幫助，到時候給面試官一個好看。

注：我用的是 OpenJDK 14。

01、Vector

Vector 的源碼文檔上直截了當地說了，“如果不需要線程安全，推薦使用 ArrayList 替代 Vector。”說實話，在我十多年的程式設計生涯中，的确很少使用 Vector，因為它的線程安全是建立在每個方法上都加了 synchronized 關鍵字的基礎上，鎖的粒度很高，意味着性能就不咋滴。

public synchronized boolean add(E e) {
    modCount++;
    add(e, elementData, elementCount);
    return true;
}
public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);
    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    elementData[--elementCount] = null; // Let gc do its work
    return oldValue;
}      

就連 size() 這樣的方法上都加了 synchronized，可想而知，Vector 有多鋪張浪費，有多錦衣玉食。

如果對 synchronized 關鍵字不太了解的話，可以點選下面的連結檢視我之前寫的一篇文章。

我去，你竟然還不會用 synchronized

高并發的情況下，一般都要求性能要給力，Vector 顯然不夠格，是以被遺忘在角落也是“罪有應得”啊。

02、SynchronizedList

那有些同學可能會說，可以使用 Collections.synchronizedList() 讓 ArrayList 變成線程安全啊。

public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
            new Collections.SynchronizedRandomAccessList<>(list) :
            new Collections.SynchronizedList<>(list));
}      

無論是 SynchronizedRandomAccessList 還是 SynchronizedList，它們都沒有在方法級别上使用 synchronized 關鍵字，而是在方法體内使用了 synchronized(this) 塊。

public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
    synchronized (mutex) {return list.remove(index);}
}      

其中 mutex 為 this 關鍵字，也就是目前對象。

final Object mutex;     // Object on which to synchronize

SynchronizedCollection(Collection<E> c) {

   this.c = Objects.requireNonNull(c);

   mutex = this;

}

03、ConcurrentModificationException

ConcurrentModificationException 這個異常不知道同學們有沒有遇到過？我先來敲段代碼讓它發生一次，讓同學們認識一下。

List<String> list = new ArrayList<>();
list.add("沉默王二");
list.add("沉默王三");
list.add("一個文章真特麼有趣的程式員");
for (String str : list) {
    if ("沉默王二".equals(str)) {
        list.remove(str);
    }
}
System.out.println(list);      

運作這段代碼就會抛出 ConcurrentModificationException：

Exception in thread "main" java.util.ConcurrentModificationException

at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1012)

at java.base/java.util.ArrayList$Itr.next(ArrayList.java:966)

通過異常的堆棧資訊可以查找到，異常發生在 ArrayList 的内部類 Itr 的 checkForComodification() 方法中。

final void checkForComodification() {

   if (modCount != expectedModCount)

       throw new ConcurrentModificationException();

也就是說，在執行 checkForComodification() 方法的時候，發現 modCount 和 expectedModCount 不等，就抛出了 ConcurrentModificationException 異常。

為什麼會這樣呢？之前的代碼也沒有調用 checkForComodification() 方法啊！

那就隻能來看一下反編譯後的位元組碼了，原來 for-each 這個文法糖是通過 Iterator 實作的。

List<String> list = new ArrayList();

list.add("沉默王二");

list.add("沉默王三");

list.add("一個文章真特麼有趣的程式員");

Iterator var3 = list.iterator();

while (var3.hasNext()) {

String str = (String) var3.next();

if ("沉默王二".equals(str)) {

 list.remove(str);

}

System.out.println(list);

在執行 list.iterator() 的時候，其實傳回的就是 ArrayList 的内部類 Itr。

public Iterator<E> iterator() {

   return new ArrayList.Itr();

1

2

3

疊代器 Iterator 是 fail-fast 的，如果以任何方式（包括 remove 和

add）對疊代器進行修改的話，就會抛出 ConcurrentModificationException。

疊代器在執行 remove() 方法的時候，會對 modCount 加 1。remove() 方法内部會調用 fastRemove() 方法。

private void fastRemove(Object[] es, int i) {

   modCount++;

   final int newSize;

   if ((newSize = size - 1) > i)

       System.arraycopy(es, i + 1, es, i, newSize - i);

   es[size = newSize] = null;

當在進行下一次 next() 會執行 checkForComodification() 方法，結果發現 modCount 為 4，而 expectedModCount 為 3，于是就抛出了異常。

之是以在單線程的情況下就抛出 ConcurrentModificationException，就是為了在多線程并發的情況下，不冒任何的危險，提前規避掉其他線程對 List 修改的可能性。

ArrayList 傳回的疊代器是 fail-fast 的，Vector 的也是，SynchronizedList 的也是。這就意味着它們在多線程環境下通過 for-each 周遊進行增删操作的時候會出問題。