ArrayList 为什么线程不安全

一、源码分析

首先看看这个类所拥有的部分属性字段：

public class ArrayList<E> extends AbstractList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
 /**
 * 列表元素集合数组如果新建ArrayList对象时没有指定大小，那么会将 
 * EMPTY_ELEMENTDATA赋值给elementData，
 * 并在第一次添加元素时，将列表容量设置为DEFAULT_CAPACITY 
 */
 transient Object[] elementData; 
 // 列表大小，elementData中存储的元素个数
 private int size;
}

通过这两个字段可以看出，ArrayList 的实现主要就是：
1️⃣用了一个 Object 的数组，用来保存所有的元素；
2️⃣一个 size 变量用来保存当前数组中已经添加了多少元素。

接着看下最重要的 add 操作时的源代码：

public boolean add(E e) {
 ensureCapacityInternal(size + 1); // Increments modCount!!
 elementData[size++] = e;
 return true;
}

ensureCapacityInternal() 的作用就是如果将当前的新元素加到列表后面，判断列表的 elementData 数组的大小是否满足。如果 size + 1 的这个需求长度大于 elementData 这个数组的长度，那么就要对这个数组进行扩容。由此看到 add 元素时，实际有两个大的步骤：
1️⃣判断 elementData 数组 capacity 容量是否满足需求，是否需要扩容。
2️⃣在 elementData 对应位置上设置值。

这样就出现了第一个导致线程不安全的隐患，在多个线程进行 add 操作时可能会导致 elementData 数组越界。

二、ArrayList 线程不安全的原因

ArrayList 默认数组大小为 10。假设现在已经添加进去 9 个元素了，size = 9。

1. 线程 A 执行完 add 方法中的 ensureCapacityInternal(size+1) 挂起了。
2. 线程 B 开始执行，校验数组容量发现不需要扩容。于是把 “b” 放在了下标为 9 的位置，且 size 自增 1。此时 size = 10。
3. 线程 A 接着执行，尝试把 “a” 放在下标为 10 的位置，因为 size = 10。但因为数组还没有扩容，最大的下标才为 9，所以会抛出数组越界异常ArrayIndexOutOfBoundsException。

另外第二步 elementData[size++] = e 设置值的操作同样会导致线程不安全。从这里可以看出，这步操作也不是一个原子操作，它由如下两步操作构成：

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

在单线程执行这两条代码时没有任何问题，但是当多线程环境下执行时，可能就会发生一个线程的值覆盖另一个线程添加的值，具体逻辑如下：

1. 列表大小为 0，即size=0
2. 线程 A 开始添加一个元素，值为 A。此时它执行第一条操作，将 A 放在了 elementData 下标为 0 的位置上。
3. 接着线程 B 刚好也要开始添加一个值为 B 的元素，且走到了第一步操作。此时线程 B 获取到 size 的值依然为 0，于是它将 B 也放在了 elementData 下标为 0 的位置上。
4. 线程 A 开始将 size 的值增加为 1。
5. 线程 B 开始将 size 的值增加为 2。
6. 这样线程 AB 执行完毕后，理想中情况为 size 为 2，elementData 下标 0 的位置为 A，下标 1 的位置为 B。而实际情况变成了 size 为 2，elementData 下标为 0 的位置变成了 B，下标 1 的位置上什么都没有。并且后续除非使用 set 方法修改此位置的值，否则将一直为 null，因为 size 为 2，添加元素时会从下标为 2 的位置上开始。

三、案例复现

用如下的代码可以进行安全性的校验：

public static void main(String[] args) {
    final List<Integer> list = new ArrayList<Integer>();
    try {
        // 线程A将0-1000添加到list
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    list.add(i);
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        // 线程B将1000-2000添加到列表
        new Thread(new Runnable() {
            public void run() {
                for (int i = 1000; i < 2000; i++) {
                    list.add(i);
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 打印所有结果
    for (int i = 0; i < list.size(); i++) {
        System.out.println("第" + (i + 1) + "个元素为：" + list.get(i));
    }
}

最后的输出结果中，有如下的部分：

第7个元素为：3
第8个元素为：1003
第9个元素为：4
第10个元素为：1004
第11个元素为：null
第12个元素为：1005
第13个元素为：6

可以看到第 11 个元素的值为 null，这也就是上面所说的情况。多测试几次的话，数组越界的异常也可以复现出来。