解决——》Exception in thread "main" java.util.ConcurrentModificationException

我会带着你远行 2024-02-19 13:55 27阅读 0赞

版权声明：本文为博主原创文章，无需授权即可转载，甚至无需保留以上版权声明，转载时请务必注明作者。  
[https://blog.csdn.net/weixin\_43453386/article/details/84587536][https_blog.csdn.net_weixin_43453386_article_details_84587536]

#### 解决——》Exception in thread "main" java.util.ConcurrentModificationException ####

*   *  1、操作（这三种情况都会报错）
     *   *  1）第1种错误情况
         *  2）第2种错误情况
         *  3）第3种错误情况
     *  2、现象（错误信息）
     *  3、原因
     *   *  1）ArrayList源码
     *  4、解决
     *   *  1）方案1：使用Iterator提供的remove方法，用于删除当前元素
         *  2）方案2：建一个集合，记录需要删除的元素，之后统一删除
         *  3）方案3：不使用Iterator进行遍历，需要注意的是自己保证索引正常
         *  4）方案4：多线程中进行操作

ConcurrentModificationException )

### 1、操作（这三种情况都会报错） ###

#### 1）第1种错误情况 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            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
                }
            }
    	}
    }

#### 2）第2种错误情况 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            myList.add( "1");
            myList.add( "2");
            myList.add( "3");
            myList.add( "4");
            myList.add( "5");
    		
            for (Iterator<String> it = myList.iterator(); it.hasNext();) {
        
                 String value = it.next();
                  if (value.equals( "3")) {
        
                      myList.remove(value);  // error
                 }
            }
    	}
    }

#### 3）第3种错误情况 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            myList.add( "1");
            myList.add( "2");
            myList.add( "3");
            myList.add( "4");
            myList.add( "5");
    		
            for (String value : myList) {
        
                System. out.println( "List Value:" + value);
                 if (value.equals( "3")) {
        
                     myList.remove(value);  // error
                }
           } 
    
    
        }
    }

### 2、现象（错误信息） ###

Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    	at java.util.ArrayList$Itr.next(ArrayList.java:859)
    	at com.ejudata.platform.test.T.main(T.java:14)

### 3、原因 ###

以上3种情况都是使用Iterator进行遍历，且都是通过ArrayList.remove(Object) 进行删除操作

> List、Set、Map 都可以通过Iterator进行遍历，在使用其他集合遍历时进行增删操作都需要留意是否会触发ConcurrentModificationException异常。

`通过下面的ArrayList源码，可以知道List中维持了这样一个遍历modcount，用来记录List和Iterator中修改数据结构的次数。`

`当删除元素的时候，List中的modcount的次数会减少1，但Iterator的次数没有减少，一旦这两个modcount的次数不相等，就会报ConcurrentModificationException错误。`

#### 1）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];
            }   
            //其余代码不在这里显示
         }
    }

### 4、解决 ###

#### 1）方案1：使用Iterator提供的remove方法，用于删除当前元素 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            myList.add( "1");
            myList.add( "2");
            myList.add( "3");
            myList.add( "4");
            myList.add( "5");
            for (Iterator<String> it = myList.iterator(); it.hasNext();) {
        
                String value = it.next();
                if (value.equals( "3")) {
        
                    it.remove();  // ok
                }
            }
            System. out.println( "List Value:" + myList.toString());
        }
    }

#### 2）方案2：建一个集合，记录需要删除的元素，之后统一删除 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            myList.add( "1");
            myList.add( "2");
            myList.add( "3");
            myList.add( "4");
            myList.add( "5");
            List<String> templist = new ArrayList<String>();
            for (String value : myList) {
        
                if (value.equals( "3")) {
        
                    templist.add(value);
                }
            }
            // 可以查看removeAll源码，其中使用Iterator进行遍历
            myList.removeAll(templist);
            System. out.println( "List Value:" + myList.toString());
        }

#### 3）方案3：不使用Iterator进行遍历，需要注意的是自己保证索引正常 ####

import java.util.*;
    
    public class T {
        
        public static void main(String[] args) {
        
            List<String> myList = new ArrayList<String>();
            myList.add( "1");
            myList.add( "2");
            myList.add( "3");
            myList.add( "4");
            myList.add( "5");
            for ( int i = 0; i < myList.size(); i++) {
        
                String value = myList.get(i);
                System. out.println( "List Value:" + value);
                if (value.equals( "3")) {
        
                    myList.remove(value);  // ok
                    i--; // 因为位置发生改变，所以必须修改i的位置
                }
            }
            System. out.println( "List Value:" + myList.toString());
        }
    }

#### 4）方案4：多线程中进行操作 ####

import java.util.*;
    import java.util.concurrent.CopyOnWriteArrayList;
    
    public class T {
        
        public static void main(String[] args) {
        
            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();
        }
    }

[https_blog.csdn.net_weixin_43453386_article_details_84587536]: https://blog.csdn.net/weixin_43453386/article/details/84587536