你好，我是看山。
我们都知道，Java中的ArrayList是非线程安全的，这个知识点太熟了，甚至面试的时候都很少问了。
但是我们真的清楚原理吗？或者知道多线程情况下使用ArrayList会发生什么？
前段时间，我们就踩坑了，而且直接踩了两个坑，今天就来扒一扒。
翠花，上源码
上代码之前先说下ArrayList的add逻辑：
附上代码，有兴趣的可以在看看源码。
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
// 判断数组容量是否足够，如果不足，增加1.5倍，size是当前队列长度
ensureCapacityInternal(size + 1); // Increments modCount!!
// 给下标为size的赋值，同时队列长度+1，下标从0开始
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断是否首次添加元素，如果是，返回默认队列长度，现在是10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 如果不是首次添加元素，就返回当前队列长度+1
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// 如果需要的长度大于队列中数组长度，扩容，如果可以满足需求，就不用扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 这里就是扩容1.5倍的代码
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}就是这么不安全
从上面代码可以看出，ArrayList中一丁点考虑多线程的元素都没有，完全的效率优先。
奇怪的ArrayIndexOutOfBoundsException
先做一个假设，此时数组长度达到临界边缘，比如目前容量是10，现在已经有9个元素，也就是size=9，然后有两个线程同时向队列中增加元素：
仅仅差了一步，线程2就成为了抛异常的凶手。但是抛出异常还是好的，因为我们知道出错了，可以沿着异常
诡异的null元素
这种情况不太容易从代码中发现，得对代码稍加改造，elementData[size++] = e这块代码其实执行了两步：
elementData[size] = e;
size++;假设还是有两个线程要赋值，此时数组长度还比较富裕，比如数组长度是10，目前size=5：
也就是说，添加了2个元素，队列长度+2，但是真正加入队列的元素只有1个，有一个被覆盖了。
这种情况不会立马报错，排查起来就很麻烦了。而且随着JDK 8的普及，可能随手使用filter过滤空元素，这样就不会立马出错，直到出现业务异常之后才能发现，到那时，错误现场已经不见了，排查起来一头雾水。
有同学会问，源码中是elementData[size++] = e，是一行操作，为什么会拆成两步执行呢？其实这得从JVM字节码说起了。
通过JVM字节码说说第二种异常出现的原因
先来一段简单的代码：
public class Main {
public static void main(String[] args) {
int[] nums = new int[3];
int index = 0;
nums[index++] = 5;
}
}通过javac Main.java和javap -v -l Main.class组合操作得到字节码：
下面那些中文是我后加的备注，备注中还列出了局部变量表和栈值的变化，需要有点耐心。
public class Main
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #3.#12 // java/lang/Object."<init>":()V
#2 = Class #13 // Main
#3 = Class #14 // java/lang/Object
#4 = Utf8 <init>
#5 = Utf8 ()V
#6 = Utf8 Code
#7 = Utf8 LineNumberTable
#8 = Utf8 main
#9 = Utf8 ([Ljava/lang/String;)V
#10 = Utf8 SourceFile
#11 = Utf8 Main.java
#12 = NameAndType #4:#5 // "<init>":()V
#13 = Utf8 Main
#14 = Utf8 java/lang/Object
{
public Main();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=3, locals=3, args_size=1 局部变量表 栈
0: iconst_3 // 将int型(3)推送至栈顶 args 3
1: newarray int // 创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶 args 数组引用
3: astore_1 // 将栈顶引用型数值存入第二个本地变量 args, nums=数组引用 null
4: iconst_0 // 将int型(0)推送至栈顶 args, nums=数组引用 0
5: istore_2 // 将栈顶int型数值存入第三个本地变量 args, nums=数组引用, index=0 null
6: aload_1 // 将第二个引用类型本地变量推送至栈顶 args, nums=数组引用, index=0 数组引用
7: iload_2 // 将第三个int型本地变量推送至栈顶 args, nums=数组引用, index=0 0, 数组引用
8: iinc 2, 1 // 将指定int型变量增加指定值（i++, i--, i+=2），也就是第三个本地变量增加1 args, nums=数组引用, index=1 0, 数组引用
11: iconst_5 // 将int型(5)推送至栈顶 args, nums=数组引用, index=1 5, 0, 数组引用
12: iastore // 将栈顶int型数值存入指定数组的指定索引位置 args, nums=数组引用, index=1 null
13: return // 从当前方法返回void
LineNumberTable:
line 3: 0 // int[] nums = new int[3];
line 4: 4 // int index = 0;
line 5: 6 // nums[index++] = 5;
line 6: 13 // 方法结尾默认的return
}从上面的字节码可以看到，nums[index++] = 5这一句会被转为5个指令，是从6到12。大体操作如下：
也即是说，错误出在数组赋值操作时先将数组引用和下标同时压入栈顶，与下标赋值是两步，在多线程环境中，就有可能出现上面说到的null值存在。
解法
其实解法也很简单，就是要意识到多线程环境，然后不使用ArrayList。可以使用Collections.synchronizedList()返回的同步队列，也可以使用CopyOnWriteArrayList这个队列，或者自己扩展ArrayList，将add方法做成同步方法。
文末总结
ArrayList整个类的操作都是非线程安全的，一旦在多线程环境中使用，就可能会出现问题。上面提到add操作就会有两种异常行为，一个是数组越界异常，一个是出现丢数且出现空值。这还只是最简单的add操作，如果add、addAll和get混合使用使用时，异常情况就更多了。所以，使用的时候一定要注意是不是单线程操作，如果不是，果断使用其他队列防雷。
推荐阅读
你好，我是看山，公众号：看山的小屋，10 年老猿，开源贡献者。游于码界，戏享人生。
原创文章，作者：kepupublish，如若转载，请注明出处：https://blog.ytso.com/175862.html