Java ConcurrentModificationException 异常分析与解决方案

比眉伴天荒 2024-05-23 22:21 50阅读 0赞

## Java ConcurrentModificationException 异常分析与解决方案 ##

### 单线程 ###

#### 异常情况举例 ####

*  只要抛出出现异常，可以肯定的是代码一定有错误的地方。先来看看都有哪些情况会出现ConcurrentModificationException异常，下面以ArrayList remove 操作进行举例：
 *  使用的数据集合：
 *  List myList = new ArrayList();
 *      myList.add( "1");
               myList.add( "2");
               myList.add( "3");
               myList.add( "4");
               myList.add( "5");
 *      以下三种情况都会出现异常：
                   Iterator<String> it = myList.iterator();
                    while (it.hasNext()) {
                        String value = it.next();
                         if (value.equals( "3")) {
                             myList.remove(value);  // error
                        }
                    }
              
                 for (Iterator<String> it = myList.iterator(); it.hasNext();) {
                    String value = it.next();
                     if (value.equals( "3")) {
                         myList.remove(value);  // error
                     }
                 }
                 for (String value : myList) {
                    System. out.println( "List Value:" + value);
                     if (value.equals( "3")) {
                         myList.remove(value);  // error
                      }
                 }
 *  异常信息如下：  
    Exception in thread “main” java.util.ConcurrentModificationException  
    at java.util.AbstractList I t r . c h e c k F o r C o m o d i f i c a t i o n ( U n k n o w n S o u r c e ) a t j a v a . u t i l . A b s t r a c t L i s t Itr.checkForComodification(Unknown Source) at java.util.AbstractList Itr.checkForComodification(UnknownSource)atjava.util.AbstractListItr.next(Unknown Source)

#### 根本原因 ####

*  以上都有3种出现异常的情况有一个共同的特点，都是使用Iterator进行遍历，且都是通过ArrayList.remove(Object) 进行删除操作。  
    想要找出根本原因，直接查看ArrayList源码看为什么出现异常：
 *      public class ArrayList<E> extends AbstractList<E>
                implements Cloneable, Serializable, RandomAccess {
                
                
                 @Override public boolean remove(Object object) {
                Object[] a = array;
                int s = size;
                if (object != null) {
                    for (int i = 0; i < s; i++) {
                        if (object.equals(a[i])) {
                            System.arraycopy(a, i + 1, a, i, --s - i);
                            a[s] = null;  // Prevent memory leak
                            size = s;
                            modCount++;  // 只要删除成功都是累加
                            return true;
                        }
                    }
                } else {
                    for (int i = 0; i < s; i++) {
                        if (a[i] == null) {
                            System.arraycopy(a, i + 1, a, i, --s - i);
                            a[s] = null;  // Prevent memory leak
                            size = s;
                            modCount++;  // 只要删除成功都是累加
                            return true;
                        }
                    }
                }
                return false;
            }   
         
         
            @Override public Iterator<E> iterator() {
                return new ArrayListIterator();
            }   
                
            private class ArrayListIterator implements Iterator<E> {
                  ......
           
                  // 全局修改总数保存到当前类中
                /** The expected modCount value */
                private int expectedModCount = modCount;
         
                @SuppressWarnings("unchecked") public E next() {
                    ArrayList<E> ourList = ArrayList.this;
                    int rem = remaining;
                       // 如果创建时的值不相同，抛出异常
                    if (ourList.modCount != expectedModCount) {
                        throw new ConcurrentModificationException();
                    }
                    if (rem == 0) {
                        throw new NoSuchElementException();
                    }
                    remaining = rem - 1;
                    return (E) ourList.array[removalIndex = ourList.size - rem];
                }   
                
                  ......
             }
        }
 *  List、Set、Map 都可以通过Iterator进行遍历，这里仅仅是通过List举例，在使用其他集合遍历时进行增删操作都需要留意是否会触发ConcurrentModificationException异常。

#### 解决方案 ####

*  上面列举了会出现问题的几种情况，也分析了问题出现的根本原因，现在来总结一下怎样才是正确的，如果避免遍历时进行增删操作不会出现ConcurrentModificationException异常。
 *      public class ArrayList<E> extends AbstractList<E>
                implements Cloneable, Serializable, RandomAccess {
                
                
                 @Override public boolean remove(Object object) {
                Object[] a = array;
                int s = size;
                if (object != null) {
                    for (int i = 0; i < s; i++) {
                        if (object.equals(a[i])) {
                            System.arraycopy(a, i + 1, a, i, --s - i);
                            a[s] = null;  // Prevent memory leak
                            size = s;
                            modCount++;  // 只要删除成功都是累加
                            return true;
                        }
                    }
                } else {
                    for (int i = 0; i < s; i++) {
                        if (a[i] == null) {
                            System.arraycopy(a, i + 1, a, i, --s - i);
                            a[s] = null;  // Prevent memory leak
                            size = s;
                            modCount++;  // 只要删除成功都是累加
                            return true;
                        }
                    }
                }
                return false;
            }   
         
         
            @Override public Iterator<E> iterator() {
                return new ArrayListIterator();
            }   
                
            private class ArrayListIterator implements Iterator<E> {
                  ......
           
                  // 全局修改总数保存到当前类中
                /** The expected modCount value */
                private int expectedModCount = modCount;
         
                @SuppressWarnings("unchecked") public E next() {
                    ArrayList<E> ourList = ArrayList.this;
                    int rem = remaining;
                       // 如果创建时的值不相同，抛出异常
                    if (ourList.modCount != expectedModCount) {
                        throw new ConcurrentModificationException();
                    }
                    if (rem == 0) {
                        throw new NoSuchElementException();
                    }
                    remaining = rem - 1;
                    return (E) ourList.array[removalIndex = ourList.size - rem];
                }   
                  ......
             }
        }
 *  输出结果都是：List Value:\[1, 2, 4, 5\] ， 不会出现异常。  
    以上4种解决办法在单线程中测试完全没有问题，但是如果在多线程中呢？

### 多线程 ###

#### 同步异常情况举例 ####

*  上面针对ConcurrentModificationException异常在单线程情况下提出了4种解决方案，本来是可以很哈皮的洗洗睡了，但是如果涉及到多线程环境可能就不那么乐观了。
 *  下面的例子中开启两个子线程，一个进行遍历，另外一个有条件删除元素：
 *      final List<String> myList = createTestData();
          
          new Thread(new Runnable() {
           
               @Override
               public void run() {
                    for (String string : myList) {
                         System.out.println("遍历集合 value = " + string);
                     
                         try {
                              Thread.sleep(100);
                         } catch (InterruptedException e) {
                              e.printStackTrace();
                         }
                    }
               }
          }).start();
          
          new Thread(new Runnable() {
           
               @Override
               public void run() {
                
                 for (Iterator<String> it = myList.iterator(); it.hasNext();) {
                     String value = it.next();
                 
                     System.out.println("删除元素 value = " + value);
                 
                     if (value.equals( "3")) {
                          it.remove();
                     }
                 
                     try {
                              Thread.sleep(100);
                         } catch (InterruptedException e) {
                              e.printStackTrace();
                         }
                }
               }
          }).start();
 *  输出结果：  
    遍历集合 value = 1  
    删除元素 value = 1  
    遍历集合 value = 2  
    删除元素 value = 2  
    遍历集合 value = 3  
    删除元素 value = 3
 *  Exception in thread “Thread-0” 删除元素 value = 4  
    java.util.ConcurrentModificationException  
    at java.util.AbstractList I t r . c h e c k F o r C o m o d i f i c a t i o n ( U n k n o w n S o u r c e ) a t j a v a . u t i l . A b s t r a c t L i s t Itr.checkForComodification(Unknown Source) at java.util.AbstractList Itr.checkForComodification(UnknownSource)atjava.util.AbstractListItr.next(Unknown Source)  
    at list.ConcurrentModificationExceptionStudy$1.run(ConcurrentModificationExceptionStudy.java:42)  
    at java.lang.Thread.run(Unknown Source)  
    删除元素 value = 5
 *  结论：
 *  上面的例子在多线程情况下，仅使用单线程遍历中进行删除的第1种解决方案使用it.remove()，但是测试得知4种的解决办法中的1、2、3依然会出现问题。
 *  接着来再看一下JavaDoc对java.util.ConcurrentModificationException异常的描述：  
    当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
 *  说明以上办法在同一个线程执行的时候是没问题的，但是在异步情况下依然可能出现异常。

#### 尝试方案 ####

*  在所有遍历增删地方都加上synchronized或者使用Collections.synchronizedList，虽然能解决问题但是并不推荐，因为增删造成的同步锁可能会阻塞遍历操作。
 *  推荐使用ConcurrentHashMap或者CopyOnWriteArrayList。
 *  **CopyOnWriteArrayList注意事项**
    
     *  CopyOnWriteArrayList不能使用Iterator.remove()进行删除。
     *  CopyOnWriteArrayList使用Iterator且使用List.remove(Object);会出现如下异常：  
        java.lang.UnsupportedOperationException: Unsupported operation remove  
        at java.util.concurrent.CopyOnWriteArrayList$ListIteratorImpl.remove(CopyOnWriteArrayList.java:804)

#### 解决方案 ####

*  单线程情况下列出4种解决方案，但是发现在多线程情况下仅有第4种方案才能在多线程情况下不出现问题。
 *      List<String> myList = new CopyOnWriteArrayList<String>();
                   myList.add( "1");
                   myList.add( "2");
                   myList.add( "3");
                   myList.add( "4");
                   myList.add( "5");
         
                  new Thread(new Runnable() {
                    
                       @Override
                       public void run() {
                            for (String string : myList) {
                                 System.out.println("遍历集合 value = " + string);
                              
                                 try {
                                      Thread.sleep(100);
                                 } catch (InterruptedException e) {
                                      e.printStackTrace();
                                 }
                            }
                       }
                  }).start();
               
                  new Thread(new Runnable() {
                    
                       @Override
                       public void run() {
                         
                            for (int i = 0; i < myList.size(); i++) {
                                 String value = myList.get(i);
                              
                                 System.out.println("删除元素 value = " + value);
                          
                             if (value.equals( "3")) {
                                  myList.remove(value);
                                  i--; // 注意                           
                             }
                          
                             try {
                                      Thread.sleep(100);
                                 } catch (InterruptedException e) {
                                      e.printStackTrace();
                                 }
                            }
                       }
                  }).start();
 *  输出结果：  
    删除元素 value = 1  
    遍历集合 value = 1  
    删除元素 value = 2  
    遍历集合 value = 2  
    删除元素 value = 3  
    遍历集合 value = 3  
    删除元素 value = 4  
    遍历集合 value = 4  
    删除元素 value = 5  
    遍历集合 value = 5