看山聊并发：如果非要在多线程中使用ArrayList会发生什么？

野性酷女 2021-09-25 04:10 286阅读 0赞

![如果非要在多线程中使用ArrayList会发生什么？][ArrayList]  
你好，我是看山。

我们都知道，Java中的ArrayList是非线程安全的，这个知识点太熟了，甚至面试的时候都很少问了。

但是我们真的清楚原理吗？或者知道多线程情况下使用ArrayList会发生什么？

前段时间，我们就踩坑了，而且直接踩了两个坑，今天就来扒一扒。

## 翠花，上源码 ##

上代码之前先说下`ArrayList`的`add`逻辑：

1.  检查队列中数组是否还没有添加过元素
2.  如果是，设置当前需要长度为10，如果否，设置当前需要长度为当前队列长度+1
3.  判断需要长度是否大于数组大小
4.  如果是，需要扩容，将数组长度扩容1.5倍（第一次扩容会从0直接到10，后续会按照1.5倍的步幅增长）
5.  数组中添加元素，队列长度+1

附上代码，有兴趣的可以在看看源码。

/** * 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，然后有两个线程同时向队列中增加元素：

1.  线程1开始进入`add`方法，获取size=9，调用`ensureCapacityInternal`方法进行容量判断，此时数组容量是10，不需要扩容
2.  线程2也进入`add`方法，获取size=9，调用`ensureCapacityInternal`方法进行容量判断，此时数组容量还是10，也不需要扩容
3.  线程1开始赋值值了，也就是`elementData[size++] = e`，此时size变成10，达到数组容量极限
4.  线程2此次开始执行赋值操作，使用的size=10，也就是`elementData[10] = e`，因为下标从0开始，目前数组容量是10，直接报数组越界`ArrayIndexOutOfBoundsException`。

仅仅差了一步，线程2就成为了抛异常的凶手。但是抛出异常还是好的，因为我们知道出错了，可以沿着异常

### 诡异的null元素 ###

这种情况不太容易从代码中发现，得对代码稍加改造，`elementData[size++] = e`这块代码其实执行了两步：

elementData[size] = e;
    size++;

假设还是有两个线程要赋值，此时数组长度还比较富裕，比如数组长度是10，目前size=5：

1.  线程1开始进入`add`方法，获取size=5，调用`ensureCapacityInternal`方法进行容量判断，此时数组容量是10，不需要扩容
2.  线程2也进入`add`方法，获取size=5，调用`ensureCapacityInternal`方法进行容量判断，此时数组容量还是10，也不需要扩容
3.  线程1开始赋值，执行`elementData[size] = e`，此时size=5，在执行`size++`之前，线程2开始赋值了
4.  线程2开始赋值，执行`elementData[size] = e`，此时size还是5，所以线程2把线程1赋的值覆盖了
5.  线程1开始执行`size++`，此时size=6
6.  线程2开始执行`size++`，此时size=7

也就是说，添加了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。大体操作如下：

1.  将数组、下标压入栈
2.  给下标加值
3.  将新值压入栈
4.  取栈顶三个元素开始给元素指定下标赋值

也即是说，错误出在数组赋值操作时先将数组引用和下标同时压入栈顶，与下标赋值是两步，在多线程环境中，就有可能出现上面说到的null值存在。

## 解法 ##

其实解法也很简单，就是要意识到多线程环境，然后不使用ArrayList。可以使用`Collections.synchronizedList()`返回的同步队列，也可以使用`CopyOnWriteArrayList`这个队列，或者自己扩展`ArrayList`，将add方法做成同步方法。

## 文末总结 ##

`ArrayList`整个类的操作都是非线程安全的，一旦在多线程环境中使用，就可能会出现问题。上面提到`add`操作就会有两种异常行为，一个是数组越界异常，一个是出现丢数且出现空值。这还只是最简单的`add`操作，如果`add`、`addAll`和`get`混合使用使用时，异常情况就更多了。所以，使用的时候一定要注意是不是单线程操作，如果不是，果断使用其他队列防雷。

--------------------

你好，我是看山，公众号：看山的小屋，10 年老后端，Apache Storm、WxJava、Cynomys 开源贡献者。主业：程序猿，兼职：架构师。游于码界，戏享人生。

个人主页: [https://www.howardliu.cn][https_www.howardliu.cn]  
个人博文: [如果非要在多线程中使用ArrayList会发生什么？][ArrayList 1]  
CSDN主页: [http://blog.csdn.net/liuxinghao][http_blog.csdn.net_liuxinghao]  
CSDN博文: [如果非要在多线程中使用ArrayList会发生什么？][ArrayList 2]

![公众号：看山的小屋][21785bb43b333b0ff8efda479e715378.png]

[ArrayList]: /images/20210923/8005e264c3dc4aa280d476f0930469c2.png
[https_www.howardliu.cn]: https://www.howardliu.cn
[ArrayList 1]: https://www.howardliu.cn/arraylist-is-not-thread-safe/
[http_blog.csdn.net_liuxinghao]: http://blog.csdn.net/liuxinghao
[ArrayList 2]: https://blog.csdn.net/liuxinghao/article/details/103794938
[21785bb43b333b0ff8efda479e715378.png]: /images/20210923/79555b9e6c404f93a15107ee846e98bb.png