ArrayList为什么是线程不安全的

源码分析

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

public class ArrayList extends AbstractList
 implements List, 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 默认数组大小为 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) throws InterruptedException {
   final List list = new ArrayList();
   // 线程A将0-1000添加到list
   new Thread(new Runnable() {
       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);
      // 打印所有结果
       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,这也就是我们上面所说的情况。
多测试几次的话,数组越界的异常也可以复现出来。

你可能感兴趣的:(ArrayList为什么是线程不安全的)