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

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

public class ListDemo01 {
    public static void main(String[] args) {
        List<String> li=new ArrayList<>();
        li.add("java");
        li.add("html");
        li.add("css");
        li.add("javascript");
        Iterator<String > it=li.iterator();
        while(it.hasNext()){
            String s=it.next();
            if(s.equals("html")){
               li.add("jvm");
            }
        }
        System.out.println(li);
    }
}
/*at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)
	at com.pp.lesson09.ListDemo01.main(ListDemo01.java:17)*/

异常分析：

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

//List 的add和iteration方法
public interface List<E> extends Collection<E> {
        Iterator<E> iterator();
        boolean add(E e);
}
//ArrayList实现了List接口并重写了这两个方法
public class ArrayList<E> extends AbstractList<E> implements List<E>{
         public boolean add(E e) {
            modCount++;
            add(e, elementData, size);
            return true;
        }
         public Iterator<E> iterator() {
            return new Itr();
        }
}
//在ArrayList里面new了一个Itr(),找到Itr并找到抛出异常时提示的next和checkForComodification方法
private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*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异常。

解决方法一：使用get()

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

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<String> li=new ArrayList<>();
        li.add("java");
        li.add("html");
        li.add("css");
        li.add("javascript");
        ListIterator<String > 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<E> extends AbstractList<E> implements List<E>{
    public ListIterator<E> listIterator() {
        return new ListItr(0);
     }
}
//ListItr类其实是实现了ListIterator接口的
//public interface ListIterator<E> extends Iterator<E> 
private class ListItr extends Itr implements ListIterator<E> {
    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++;