java.util.ConcurrentModificationException 异常问题（一）

曾经终败给现在 2024-05-01 16:01 16阅读 0赞

**1.1 问题复现**

>     public void test1()  {
>             ArrayList<Integer> arrayList = new ArrayList<>();
>             for (int i = 0; i < 20; i++) {
>                 arrayList.add(Integer.valueOf(i));
>             }
>     
>             // 复现方法一
>             Iterator<Integer> iterator = arrayList.iterator();
>             while (iterator.hasNext()) {
>                 Integer integer = iterator.next();
>                 if (integer.intValue() == 5) {
>                     arrayList.remove(integer);
>                 }
>             }
>     
>             // 复现方法二
>             iterator = arrayList.iterator();
>             for (Integer value : arrayList) {
>                 Integer integer = iterator.next();
>                 if (integer.intValue() == 5) {
>                     arrayList.remove(integer);
>                 }
>             }
>         }

**1.2、问题原因分析**

先来看实现方法一，方法一中使用Iterator遍历ArrayList， 抛出异常的是iterator.next(),看下Iterator next方法实现源码

> public E next() \{  
> checkForComodification();  
> int i = cursor;  
> if (i >= size)  
> throw new NoSuchElementException();  
> Object\[\] elementData = ArrayList.this.elementData;  
> if (i >= elementData.length)  
> throw new ConcurrentModificationException();  
> cursor = i + 1;  
> return (E) elementData\[lastRet = i\];  
> \}
> 
> final void checkForComodification() \{  
> if (modCount != expectedModCount)  
> throw new ConcurrentModificationException();  
> \}

在next方法中首先调用了checkForComodification方法，该方法会判断modCount是否等于expectedModCount，不等于就会抛出java.util.ConcurrentModificationExcepiton异常。

我们接下来跟踪看一下modCount和expectedModCount的赋值和修改。

modCount是ArrayList的一个属性，继承自抽象类AbstractList，用于表示ArrayList对象被修改次数。

>     protected transient int modCount = 0;

整个ArrayList中修改modCount的方法比较多，有add、remove、clear、ensureCapacityInternal等，凡是设计到ArrayList对象修改的都会自增modCount属性。

在创建Iterator的时候会将modCount赋值给expectedModCount，在遍历ArrayList过程中，没有其他地方可以设置expectedModCount了，因此遍历过程中expectedModCount会一直保持初始值20（调用add方法添加了20个元素，修改了20次）。

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

在执行next方法时，遇到modCount != expectedModCount方法，导致抛出异常java.util.ConcurrentModificationException。

明白了抛出异常的过程，但是为什么要这么做呢？很明显这么做是为了阻止程序员在不允许修改的时候修改对象，起到保护作用，避免出现未知异常。

引用网上的一段解释，[点击查看解释来源][Link 1]

>     Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 
>     Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变。
>     当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
>     所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

再来分析下第二种for循环抛异常的原因：

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

在for循环中一开始也是对expectedModCount采用modCount进行赋值。在进行for循环时每次都会有判定条件modCount == expectedModCount，当执行完arrayList.remove(integer)之后，该判定条件返回false退出循环，然后执行if语句，结果同样抛出java.util.ConcurrentModificationException异常。

这两种复现方法实际上都是同一个原因导致的。

#### 1.3 问题解决方案 ####

上述的两种复现方法都是在单线程运行的，先来说明单线程中的解决方案：

> public void test2() \{  
> ArrayList<Integer> arrayList = new ArrayList<>();  
> for (int i = 0; i < 20; i++) \{  
> arrayList.add(Integer.valueOf(i));  
> \}
> 
> Iterator<Integer> iterator = arrayList.iterator();  
> while (iterator.hasNext()) \{  
> Integer integer = iterator.next();  
> if (integer.intValue() == 5) \{  
> iterator.remove();  
> \}  
> \}  
> \}

这种解决方案最核心的就是调用iterator.remove()方法。我们看看该方法源码为什么这个方法能避免抛出异常

> public void remove() \{  
> if (lastRet < 0)  
> throw new IllegalStateException();  
> checkForComodification();
> 
> try \{  
> ArrayList.this.remove(lastRet);  
> cursor = lastRet;  
> lastRet = -1;  
> expectedModCount = modCount;  
> \} catch (IndexOutOfBoundsException ex) \{  
> throw new ConcurrentModificationException();  
> \}  
> \}

在iterator.remove()方法中，同样调用了ArrayList自身的remove方法，但是调用完之后并非就return了，而是expectedModCount = modCount重置了expectedModCount值，使二者的值继续保持相等。

针对forEach循环并没有修复方案，因此在遍历过程中同时需要修改ArrayList对象，则需要采用iterator遍历。

上面提出的解决方案调用的是iterator.remove()方法，如果不仅仅是想调用remove方法移除元素，还想增加元素，或者替换元素，是否可以呢？浏览Iterator源码可以发现这是不行的，Iterator只提供了remove方法。

但是ArrayList的内部类ListItr实现了ListIterator接口，并继承了内部类Iter（实现了Iterator<E>），这些操作都是可以实现的，使用示例如下：

> public void test3() \{  
> ArrayList<Integer> arrayList = new ArrayList<>();  
> for (int i = 0; i < 20; i++) \{  
> arrayList.add(Integer.valueOf(i));  
> \}
> 
> ListIterator<Integer> iterator = arrayList.listIterator();  
> while (iterator.hasNext()) \{  
> Integer integer = iterator.next();  
> if (integer.intValue() == 5) \{  
> iterator.set(Integer.valueOf(6));  
> iterator.remove();  
> iterator.add(integer);  
> \}  
> \}  
> \}

**二、 多线程情况下的问题分析及解决方案**

2.1 问题复现

> public void test4() \{  
> ArrayList<Integer> arrayList = new ArrayList<>();  
> for (int i = 0; i < 20; i++) \{  
> arrayList.add(Integer.valueOf(i));  
> \}
> 
> Thread thread1 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> ListIterator<Integer> iterator = arrayList.listIterator();  
> while (iterator.hasNext()) \{  
> System.out.println("thread1 " + iterator.next().intValue());  
> try \{  
> Thread.sleep(1000);  
> \} catch (InterruptedException e) \{  
> e.printStackTrace();  
> \}  
> \}  
> \}  
> \});
> 
> Thread thread2 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> ListIterator<Integer> iterator = arrayList.listIterator();  
> while (iterator.hasNext()) \{  
> System.out.println("thread2 " + iterator.next().intValue());  
> iterator.remove();  
> \}  
> \}  
> \});  
> thread1.start();  
> thread2.start();  
> \}

在个测试代码中，开启两个线程，一个线程遍历，另外一个线程遍历加修改。程序输出结果如下

> thread1 0  
> thread2 0  
> thread2 1  
> thread2 2  
> thread2 3  
> thread2 4  
> thread2 5  
> thread2 6  
> thread2 7  
> thread2 8  
> thread2 9  
> thread2 10  
> thread2 11  
> thread2 12  
> thread2 13  
> thread2 14  
> thread2 15  
> thread2 16  
> thread2 17  
> thread2 18  
> thread2 19  
> Exception in thread "Thread-0" java.util.ConcurrentModificationException  
> at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)  
> at java.util.ArrayList$Itr.next(ArrayList.java:851)  
> at com.snow.ExceptionTest$1.run(ExceptionTest.java:74)  
> at java.lang.Thread.run(Thread.java:745)
> 
> Process finished with exit code 0

**2.2 问题分析**

从上面代码执行结果可以看出thread2 遍历结束后，thread1 sleep完1000ms准备遍历第二个元素，next的时候抛出异常了。我们从时间点分析一下抛异常的原因

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:middle;">时间点</td> 
   <td style="vertical-align:middle;">arrayList.modCount</td> 
   <td style="vertical-align:middle;">thread1 iterator.expectedModCount</td> 
   <td style="vertical-align:middle;">thread2 iterator.expectedModCount</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;">thread start，初始化iterator</td> 
   <td style="vertical-align:middle;">20</td> 
   <td style="vertical-align:middle;">20</td> 
   <td style="vertical-align:middle;">20</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;">thread2.remove()调用之后</td> 
   <td style="vertical-align:middle;">21</td> 
   <td style="vertical-align:middle;">20</td> 
   <td style="vertical-align:middle;">21</td> 
  </tr> 
 </tbody> 
</table>

两个thread都是使用的同一个arrayList，thread2修改完后modCount = 21，此时thread2的expectedModCount = 21 可以一直遍历到结束；thread1的expectedModCount仍然为20，因为thread1的expectedModCount只是在初始化的时候赋值，其后并未被修改过。因此当arrayList的modCount被thread2修改为21之后，thread1想继续遍历必定会抛出异常了。

在这个示例代码里面，两个thread，每个thread都有自己的iterator，当thread2通过iterator方法修改expectedModCount必定不会被thread1感知到。这个跟ArrayList非线程安全是无关的，即使这里面的ArrayList换成Vector也是一样的结果，不信上测试代码：

> public void test5() \{  
> Vector<Integer> vector = new Vector<>();  
> for (int i = 0; i < 20; i++) \{  
> vector.add(Integer.valueOf(i));  
> \}
> 
> Thread thread1 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> ListIterator<Integer> iterator = vector.listIterator();  
> while (iterator.hasNext()) \{  
> System.out.println("thread1 " + iterator.next().intValue());  
> try \{  
> Thread.sleep(1000);  
> \} catch (InterruptedException e) \{  
> e.printStackTrace();  
> \}  
> \}  
> \}  
> \});
> 
> Thread thread2 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> ListIterator<Integer> iterator = vector.listIterator();  
> while (iterator.hasNext()) \{  
> Integer integer = iterator.next();  
> System.out.println("thread2 " + integer.intValue());  
> if (integer.intValue() == 5) \{  
> iterator.remove();  
> \}  
> \}  
> \}  
> \});  
> thread1.start();  
> thread2.start();  
> \}

执行后输出结果为：

> thread1 0  
> thread2 0  
> thread2 1  
> thread2 2  
> thread2 3  
> thread2 4  
> thread2 5  
> thread2 6  
> thread2 7  
> thread2 8  
> thread2 9  
> thread2 10  
> thread2 11  
> thread2 12  
> thread2 13  
> thread2 14  
> thread2 15  
> thread2 16  
> thread2 17  
> thread2 18  
> thread2 19  
> Exception in thread "Thread-0" java.util.ConcurrentModificationException  
> at java.util.Vector$Itr.checkForComodification(Vector.java:1184)  
> at java.util.Vector$Itr.next(Vector.java:1137)  
> at com.snow.ExceptionTest$3.run(ExceptionTest.java:112)  
> at java.lang.Thread.run(Thread.java:745)
> 
> Process finished with exit code 0

test5()方法执行结果和test4()是相同的，那如何解决这个问题呢？

**2.3 多线程下的解决方案**

**2.3.1 方案一：iterator遍历过程加同步锁，锁住整个arrayList**

> public static void test5() \{  
> ArrayList<Integer> arrayList = new ArrayList<>();  
> for (int i = 0; i < 20; i++) \{  
> arrayList.add(Integer.valueOf(i));  
> \}
> 
> Thread thread1 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> synchronized (arrayList) \{  
> ListIterator<Integer> iterator = arrayList.listIterator();  
> while (iterator.hasNext()) \{  
> System.out.println("thread1 " + iterator.next().intValue());  
> try \{  
> Thread.sleep(100);  
> \} catch (InterruptedException e) \{  
> e.printStackTrace();  
> \}  
> \}  
> \}  
> \}  
> \});
> 
> Thread thread2 = new Thread(new Runnable() \{  
> @Override  
> public void run() \{  
> synchronized (arrayList) \{  
> ListIterator<Integer> iterator = arrayList.listIterator();  
> while (iterator.hasNext()) \{  
> Integer integer = iterator.next();  
> System.out.println("thread2 " + integer.intValue());  
> if (integer.intValue() == 5) \{  
> iterator.remove();  
> \}  
> \}  
> \}  
> \}  
> \});  
> thread1.start();  
> thread2.start();  
> \}

下接：[https://blog.csdn.net/wsen1229/article/details/103291059][https_blog.csdn.net_wsen1229_article_details_103291059]

[Link 1]: https://blog.csdn.net/wsen1229/article/details/103296804
[https_blog.csdn.net_wsen1229_article_details_103291059]: https://blog.csdn.net/wsen1229/article/details/103291059