一、ArrayList源碼摘錄

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    /**
     * 列表元素集合數組
     * 說明ArrayList基於數組存儲數據
     */
    transient Object[] elementData; 

    /**
     * 列表大小，elementData中存儲的元素個數
     */
    private int size;
}

add() 方法

/**
 * Appends the specified element to the end of this list.
 * 將指定的元素追加到列表的末尾。
 * add() 方法做了如下操作：
 *     1.檢查容量是否足夠，如不夠將進行擴容，並自增 modCount
 *     2.將指定的元素追加到列表的末尾
 *
 * @param e element to be appended to this list
 * @return <tt>true</tt> (as specified by {@link Collection#add})
 */
public boolean add(E e) {
    //確保容量足夠，如果不夠進行擴容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //將e存在index為size的位置（即最後一位的下一位置），size++
    //我們都知道，++操作不是原子指令，多線程情況下將發生併發問題
    elementData[size++] = e;
    return true;
}

二、測試用例

@Test
public void listThreadUnsafe() throws InterruptedException {
    List<String> list = new ArrayList<>();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                list.add("t1-" + i);
            }
        }
    });
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                list.add("t2-" + i);
            }
        }
    });
    t1.start();
    t2.start();

    Thread.sleep(2000);
    int size = list.size();
    System.out.println("size = " + size);
    for (int i = 0; i < size; i++) {
        System.out.println("索引為" + i + "的元素為：" + list.get(i));
    }
}

本用例多跑幾次，將出現下面幾種併發問題。

三、ArrayList線程不安全的表現

add()實際執行的過程為：

elementData[size] = e;
size = size + 1;

1. 併發環境下進行add操作時可能會導致elementData數組越界

問題現場如下：
有兩個線程：t1，t2。有ArrayList size=9（即其中有9個元素）。elementData.length=10
t1進入add()方法，這時獲取到size值為9，調用ensureCapacityInternal()方法判斷容量是否需要擴容
t2也進入add()方法，這時獲取到size值也為9，也調用ensureCapacityInternal()方法判斷容量是否需要擴容
t1發現自己的需求為size+1=10，容量足夠，無需擴容
t1發現自己的需求為也size+1=10，容量足夠，無需擴容
t1開始設置元素操作，elementData[size++] = e，成功，此時size變為10
t2也開始進行設置元素操作，它嘗試設置elementData[10] = e，而elementData沒有進行過擴容，它的下標最大為9。於是此時會報出一個數組越界的異常：ArrayIndexOutOfBoundsException

用例體現為：

2. 一個線程的值覆蓋另一個線程添加的值

這個問題要分多鐘情況了

2.1 情況1 size大小符合預期，但是中間有null值存在

流程描述如下：

問題現場如下：
有兩個線程：t1，t2。有ArrayList size=5（即其中有5個元素）。elementData.length=10
t1進入add()方法，這時獲取到size值為5，調用ensureCapacityInternal()方法判斷容量是否需要擴容
t2也進入add()方法，這時獲取到size值也為5，也調用ensureCapacityInternal()方法判斷容量是否需要擴容
t1發現自己的需求為size+1=6，容量足夠，無需擴容
t1發現自己的需求為也size+1=6，容量足夠，無需擴容
t1開始設置元素操作，elementData[size] = e，成功，
t2也開始設置元素操作，elementData[size] = e，成功，注意此時t1的size+1還沒執行
t1 size = size + 1 = 6，並寫入主存
t2 size = size + 1 = 7
這樣，size符合預期，但是t2設置的值被覆蓋，而且索引為6的位置將永遠為null，因為size已經為7，下次add()也會從7開始。除非手動set值。

用例體現如下：

我們發現，t2的“t2-0”元素被覆蓋。

2.2 情況2 size大小比預期的小

情況分析：

問題現場如下：
有兩個線程：t1，t2。有ArrayList size=5（即其中有5個元素）。elementData.length=10
t1進入add()方法，這時獲取到size值為5，調用ensureCapacityInternal()方法判斷容量是否需要擴容
t2也進入add()方法，這時獲取到size值也為5，也調用ensureCapacityInternal()方法判斷容量是否需要擴容
t1發現自己的需求為size+1=6，容量足夠，無需擴容
t1發現自己的需求為也size+1=6，容量足夠，無需擴容
t1開始設置元素操作，elementData[size] = e，成功，
t2也開始設置元素操作，elementData[size] = e，成功，注意此時t1的size+1還沒執行
t1 size = size + 1 = 6，暫未寫入主存
t2 size = size + 1 此時因為t1操作完size還未寫入主存，所以size依然為5，+1後仍為6
t1將size=6 寫入主存
t2將size=6 寫入主存
這樣，size=6 比預期結果小了。

用例體現：

---

總結

上面介紹的情況都有其出現的概率，並不是每次都出現，只是在臨界狀態下出現錯誤。但是，作為程序的編寫者，即使有千萬分之一的概率，我們也要儘量去避免它，這是程序員的基本素養。

Tips

關於寫入主存。
基本現在的CPU都是多核心的，每個核心有各自的高速緩存，計算任務需要在高速緩存中進行，對於緩存的訪問速度 L1 > L2 > L3 > 內存。L1、L2為各核心獨有，L3為多個核心共享。
我們的程序運行在主內存，但計算需要在CPU中完成。
當執行計算任務時，比如 size+1 操作，CPU先將 size 的值讀進CPU緩存，在CPU緩存中計算 +1，然後再將結果寫入主內存。