java List集合的并发修改异常源码分析和解决方法

当用迭代器遍历集合的同时对集合做增删等操作会有并发修改异常java.util.ConcurrentModificationException

public class ListDemo01 {
    public static void main(String[] args) {
        List li=new ArrayList<>();
        li.add("java");
        li.add("html");
        li.add("css");
        li.add("javascript");
        Iterator it=li.iterator();
        while(it.hasNext()){
            String s=it.next();
            if(s.equals("html")){
               li.add("jvm");
            }
        }
        System.out.println(li);
    }
}

这时会抛出一个并发修改异常，并且错误提示在it.next()这一行,看源码分析

//List 的add和iteration方法
public interface List extends Collection {
        Iterator iterator();
        boolean add(E e);
}
//ArrayList实现了List接口并重写了这两个方法
public class ArrayList extends AbstractList implements List{
         public boolean add(E e) {
            modCount++;
            add(e, elementData, size);
            return true;
        }
         public Iterator iterator() {
            return new Itr();
        }
}
//在ArrayList里面new了一个Itr(),找到Itr并找到抛出异常时提示的next和checkForComodification方法
private class Itr implements Iterator {
        int expectedModCount = modCount;
        
        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()方法开始分析，当调用next()方法时，在next()方法里首先调用 checkForComodification()，进到checkForComodification()方法可以看到有个一判断，当modCount != expectedModCount时就会抛出我们所看到的的并发修改异常，在Itr这个类内，刚开始expectedModCount = modCount;没错，但我们的程序里调用了add()方法，看add的源码我们会发现，在add方法内有modCount++;oh！原来我们修改了modCount，那么下次再调用next()方法的时候，modCount != expectedModCount了，就抛出ConcurrentModificationException异常。

public class ListDemo01 {
    public static void main(String[] args) {
        List li=new ArrayList<>();
        li.add("java");
        li.add("html");
        li.add("css");
        li.add("javascript");
//        Iterator it=li.iterator();
//        while(it.hasNext()){
//            String s=it.next();
//            if(s.equals("html")){
//               li.add("jvm");
//            }
//        }
        for(int i=0;i 
get()的源码: 
使用get()方法不会抛出异常，因为在get里不会检查修改次数
 
public E get(int index) {
        Objects.checkIndex(index, size);
        return elementData(index);
    }
 
解决方法二：使用List集合特有的迭代器ListIterator 
public class ListDemo01 {
    public static void main(String[] args) {
        List li=new ArrayList<>();
        li.add("java");
        li.add("html");
        li.add("css");
        li.add("javascript");
        ListIterator it= li.listIterator();
        while(it.hasNext()){
            String s=it.next();
            if(s.equals("html")){
               it.add("jvm");
            }
        }

        System.out.println(li);//[java, html, css, javascript, jvm]
    }
}
 
 在帮助文档我们可以查看到ListIterator继承自Iterator并且在迭代期间可以修改列表，并获取列表中迭代器的当前位置，所以ListIterator是List集合特有的迭代器，可用迭代器对集合进行增删改查
 
 看ListIterator的源码分析
 
//ArrayList的listIterator()方法
public class ArrayList extends AbstractList implements List{
    public ListIterator listIterator() {
        return new ListItr(0);
     }
}
//ListItr类其实是实现了ListIterator接口的
//public interface ListIterator extends Iterator 
private class ListItr extends Itr implements ListIterator {
    public void add(E e) {
          checkForComodification();

          try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = modCount;
           } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
           }
     }
}
 
 li.listIterator()其实返回的就是一个实现了ListIterator接口的对象，这个返回的对象调用add方法时，我们可以发现，在刚开始也是先调用了checkForComodification()方法去判断，但在add()方法里多了一句expectedModCount = modCount，所以使用迭代器的add()方法之后，expectedModCount = modCount，不会抛出异常，而之前的ArrayList的add()方法，只是让modCount++;