ArrayList哪几种情况下会报java.util.ConcurrentModificationException吗？

小鱼儿 2023-03-04 11:30 76阅读 0赞

ArrayList是一个很常用的集合类，底层是一个数组，只不过ArrayList封装了数组，实现了一些好用的方法例如`add()`方法，`size()`方法，`get()`方法等一系列的方法，并且实现了动态的扩容数组。  
`new ArrayList();`创建了一个空数组，那么它的容量起始为0，为什么面试过程中很多人都说ArrayList的初始容量为`10`呢？原因在于当你第一次调用`add()`方法添加元素的时候会进行一次扩容。这时候就会扩容到默认的初始容量`10`  
在ArrayList中定义了一个常量`DEFAULT_CAPACITY`，如下：  
![在这里插入图片描述][20200803171637669.png]  
关于ArrayList的源码解读可以看我之前写的博客：  
[一文搞定ArrayList、LinkedList、HashMap、HashSet -----源码解读之ArrayList][ArrayList_LinkedList_HashMap_HashSet -----_ArrayList]

本篇文章主要讲解并发修改异常出现的情况，也就是调用多线程并发调用`add()`方法

### 下面有一段测试代码 ###

ArrayList<String> arrayList = new ArrayList();
    for (int i = 0; i < 2000; i++) { //如果没有出现并发修改异常则讲循环调大点
        int finalI = i;
        new Thread(() -> { 
            arrayList.add("" + finalI);
        }, "thread:" + i).start();
    
    }
    
    arrayList.stream().forEach(System.out::println);//遍历ArrayList进行打印

下面是执行代码的输出情况  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70]

你是否有疑惑，为什么会出现并发修改异常？这个异常是怎么抛出来的？

### 解开疑惑 ###

下面跟我一起追踪源码，找到这个异常出现的位置。

我是这样做的,在`add()`方法上添加一个断点，进行`debug`调试。

会执行下面的代码

public boolean add(E e) { 
        modCount++; //注意这个参数，是来自父类的成员变量 AbstractList
        add(e, elementData, size);//近一步调用三个参数的add方法
        return true;//表示添加成功
    }

private void add(E e, Object[] elementData, int s) { 
        if (s == elementData.length) //判断是否需要扩容
            elementData = grow();//进行扩容，将扩容后的新数组重新赋值给 elementData
        elementData[s] = e; //将元素添加进数组中
        size = s + 1; // s是下标，size是实际的元素个数，因此需要 数组下标 +1 = 元素个数
    }

会发现add方法似乎并没有关于`java.util.ConcurrentModificationException`异常的任何信息。  
只是简单的将元素添加进去，如果长度不够就进行`grow()`扩容。  
那会不会是这个`grow()`方法里面抛的异常？进一步追踪到`grow()`

private Object[] grow() { 
        return grow(size + 1); //调用了带参数的 grow方法
    }

会发现这里的也没有关于并发修改异常的代码

private Object[] grow(int minCapacity) { 
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else { 
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

调用了Arrays的`copyOf()`方法对元素进行拷贝，获得一个新的数组并返回  
这里也没有并发修改异常的代码。那么到底是哪里抛的异常呢？

public static <T> T[] copyOf(T[] original, int newLength) { 
        return (T[]) copyOf(original, newLength, original.getClass());
    }

异常并非是`add()`方法中抛出的异常，而是后面遍历打印抛出来的异常  
进入遍历，当然测试代码中用的是java8的流操作打印的。  
前面遗留了一个成员变量`modCount++`这个成员变量进行自增，这个变量到底来自哪里呢，追踪一下，来到了父类`AbstarctList`,从名称也可以知道这个成员变量是用来记录修改计数的。  
在这个类搜索一下`ConcurrentModificationException`发现有11个地方有引用到（包括了注释里面的）。一个一个去看，找到了第一个地方引用的地方在内部类`Itr`中有引用，这个类之前分析过，是用来迭代遍历集合用的。换句话说就是在迭代遍历的时候检测到`modCount`与预期的值不同，然后抛出的这个异常。  
造成这个结果的原因是多线程调用`add()`这个`modCount`会进行自增。  
然后线程还没有处理完，后面又调用了迭代，进行获取元素，发现这个`modCount`计数和预期的`expectedModCount`不等，因此抛异常

##### 下面是`Itr`类中定义的方法，以及抛异常的条件 #####

final void checkForComodification() { 
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }

在这个`Itr`内部类中有两个地方调用了这个方法，分别是  
①`remove()`  
②`next()`  
这也就是说明，这两种方法可能会报`java.util.ConcurrentModificationException`

除了`Itr`这个类中有`ConcurrentModificationException`，内部类`ListItr`也有调用分别是  
③`previous()`  
④`set(E e)`  
⑤`add(E e)`  
内部类`RandomAccessSpliterator`中  
定义了下面的检测方法

static void checkAbstractListModCount(AbstractList<?> alist, int expectedModCount) { 
        if (alist != null && alist.modCount != expectedModCount) { 
            throw new ConcurrentModificationException();
        }
    }

调用的方法有  
⑥`tryAdvance(Consumer<? super E> action)`  
⑦`forEachRemaining(Consumer<? super E> action)`  
以及直接抛异常的  
⑧`<E> E get(List<E> list, int i)`方法  
最后一个可能抛异常的地方是静态内部类`SubList<E>`中的  
定义了检测并发修改异常的放法

private void checkForComodification() { 
        if (root.modCount != this.modCount)
            throw new ConcurrentModificationException();
    }

在  
`E set(int index, E element)`  
`E get(int index)`  
`int size()`  
`void add(int index, E element)`  
`E remove(int index)`  
`oid removeRange(int fromIndex, int toIndex)`  
`addAll(int index, Collection<? extends E> c)`  
`ListIterator<E> listIterator(int index)`  
都有调用上面的`checkForComodification()`都有可能抛并发修改异常。  
换句话说，如果调用了这些方法都有可能抛出`java.util.ConcurrentModificationException`异常

而在测试代码中之所以抛出`java.util.ConcurrentModificationException`异常的原因是迭代获取元素调用了`ArrayList中的forEach方法`  
传入的是一个消费性接口

@Override
     public void forEach(Consumer<? super E> action) { 
         Objects.requireNonNull(action);
         final int expectedModCount = modCount;
         final Object[] es = elementData;
         final int size = this.size;
         for (int i = 0; modCount == expectedModCount && i < size; i++)
             action.accept(elementAt(es, i));
         if (modCount != expectedModCount)
             throw new ConcurrentModificationException();
     }

由于`modCount != expectedModCount`在后面的if判断条件中符合条件因此抛出并发修改异常  
这是测试案例中通过流的`forEach`导致并发修改异常的原因。

### 总结： ###

ArrayList中的`add(E e)`方法会导致并发问题，但并不会报`java.util.ConcurrentModificationException`异常，而是在进行遍历的时候。例如测试代码中的`forEach`中抛异常。并非并发异常一定会出现，但是ArrayList的确会出现并发问题。

也就是说，不管你用多少个线程进行多少次`add(E e)`都不会抛异常，虽然的确是出现了重复写入同一个数组中的位置，但是并不能知道是那个线程导致的并发异常

[20200803171637669.png]: /images/20230208/a71d570b0df74bcdafa199d7458d4c54.png
[ArrayList_LinkedList_HashMap_HashSet -----_ArrayList]: https://blog.csdn.net/qq_41813208/article/details/107614811
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70]: /images/20230208/a24e34b8e7ef4e109887639173239560.png