Java中ArrayList的线程不安全

ArrayList内部主要是维护了一个Object类型的数组，以及一个int类型的size保存实际数据长度。

数组在创建时需要指明长度，但ArrayList通过预分配额外的空间，以及动态增长的方式实现了形式上的可变长度数组，本质上类似于STL中的vector。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 默认初始长度
    private static final int DEFAULT_CAPACITY = 10;
    // 空数组 如果创建时未指定数组大小 则默认使用此对象
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 实际保存数据的数组 注意是非private的
    transient Object[] elementData;
    // 实际的数组长度
    private int size;
}

然后，看一下ArrayList的add操作：

public boolean add(E e) {
    // 确保数组空间足够 不够时自动扩容
    ensureCapacityInternal(size + 1);
    // 添加元素进数组
    elementData[size++] = e;
    return true;
}

// ArrayList扩容操作
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 默认扩容50%
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // ...
    elementData = Arrays.copyOf(elementData, newCapacity);
}

主要是两步操作，第一步判断新增加一个元素时当前数组容量是否足够，在容量不足时会自动进行扩容，看一下扩容操作，大概是扩充为之前容量的1.5倍。第二步就是将元素放进数组中。

由此可以分析在多线程情况下可能发生的线程不安全情况，主要有两种：（1）数组越界；（2）写值覆盖。

（1）数组越界

看add的两步逻辑，先判断数组容量是否足够，然后进行写值。

多线程情况下，数组最大容量为10，此时已经写入9个值了。

• 线程A进入，判断容量，发现可以写值；
• 线程B进入，判断容量，发现可以写值；
• 线程A写值，size=9，写在数组中最后一个位置
• 线程A执行size++，当前实际容量最大容量均为10；但还未进行扩容操作；
• 线程B写值，size=10，写值引发java.lang.ArrayIndexOutOfBoundsException

（2）写值覆盖

由于add操作中的第二步本身也不是原子性操作，写值，size++本身也是分两步执行的，因此也会引发多线程不安全行为。

• 线程A写值，size=0，写在数组中第一个位置；
• 线程B写值，size=0，重复写在数组中第一个位置；
• 线程A执行size++，此时size=1；
• 线程B执行size++，此时size=2；

两个线程各执行了一次add操作，size值为2理论上是正常的，但线程A写的值被覆盖了，线程B写的值在数组中第一个位置。数组中第二个位置被跳过值为null。

以上，就是ArrayList的两种线程不安全情况。

import java.util.*;


public class Main {
    public static void main(String[] args) throws Exception {
        final List<Integer> lst = new ArrayList<>();
        CountDownLatch cd = new CountDownLatch(2);

        new Thread(() -> {
            for (int i = 1; i <= 100; ++ i) {
                try {
                    // synchronized (lst) {
                    lst.add(i);
                    // }
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            cd.countDown();
        }).start();

        new Thread(() -> {
            for (int i = 101; i <= 200; ++ i) {
                try {
                    // synchronized (lst) {
                    lst.add(i);
                    // }
                    TimeUnit.MILLISECONDS.sleep(3);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            cd.countDown();
        }).start();

        cd.await();
        for (int i = 0; i < lst.size(); i++) {
            System.out.println("第" + (i + 1) + "个元素为：" + lst.get(i));
        }
    }
}

这是一个多线程情况下，ArrayList线程不安全的演示示例。

多执行几次，会发现打印结果中会出现null，数组越界等情况。

Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 109
	at java.util.ArrayList.add(ArrayList.java:459)
	at com.example.demo.others.Main$1.run(Main.java:17)
	at java.lang.Thread.run(Thread.java:745)
第1个元素为：1
第2个元素为：2
第3个元素为：101
第4个元素为：3
第5个元素为：102
...
第48个元素为：27
第49个元素为：124
第50个元素为：null
第51个元素为：28
第52个元素为：29

相对，触发null的情况会多些，数组越界触发概率会小一些。

毕竟触发null是每次多线程执行都有可能，而触发数组越界是只有在扩容的情况下才有机会产生。