java集合--java.util.ConcurrentModificationException异常

ConcurrentModificationException 异常：并发修改异常，当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。一个线程对collection集合迭代，另一个线程对Collection进行修改的时候, 就会出现上面的异常.

下面看一下代码：

  

package cn.itcast.p4.list.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class ListIteratorException {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String>list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        Iterator it = list.iterator();
        while(it.hasNext()){
            String s = (String) it.next();
            if(s.equals("abc2")){
                list.remove(s);
            }else{
                System.out.println(s);
            }
        }
        System.out.println(list);
    }

}

 

 

 

运行结果:

abc1
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:372)
    at java.util.AbstractList$Itr.next(AbstractList.java:343)
    at cn.itcast.p4.list.demo.ListIteratorException.main(ListIteratorException.java:22)

看list.iterator()方法的源码：

    public Iterator<E> iterator() {
    return new Itr();
    }

  private class Itr implements Iterator<E> {
    /**
     * Index of element to be returned by subsequent call to next.
     */
    int cursor = 0;

    /**
     * Index of element returned by most recent call to next or
     * previous.  Reset to -1 if this element is deleted by a call
     * to remove.
     */
    int lastRet = -1;

    /**
     * The modCount value that the iterator believes that the backing
     * List should have.  If this expectation is violated, the iterator
     * has detected concurrent modification.
        通过看API AbstractList.class 发现该类里面有一个成员变量： protected transient int modCount = 0;
        是不可被序列化的变量，当对集合进行add,remove,removeRange,addAll等修改动作的时候，没操作一次,modCount加1。
        用来记录对集合修改的次数。

     */
    int expectedModCount = modCount;//上面因为翻译过来，为迭代器的expectedModCount值和List集合中的modCount 初始值一致

    public boolean hasNext() {
            return cursor != size();
    }

    public E next() {
            checkForComodification();//每调用一次next方法，都要通过此方法检测expectedModCount（迭代对象的后）
        try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
        } catch (IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
        }
    }

    public void remove() {
        if (lastRet == -1)
        throw new IllegalStateException();
            checkForComodification();

        try {
        AbstractList.this.remove(lastRet);
        if (lastRet < cursor)
            cursor--;
        lastRet = -1;
        expectedModCount = modCount;
        } catch (IndexOutOfBoundsException e) {
        throw new ConcurrentModificationException();
        }
    }
    //用来检测现在的List中的modCount与创建迭代器的时候初始expectedModCount值是否想相等，不相等，返回异常ConcurrentModificationException
    final void checkForComodification() {
        if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }
    }

可能大家对modCount还不明白，再看下AbstractList.Class里面的源代码：

 

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

    protected transient int modCount = 0;
class SubList<E> extends AbstractList<E> {
  
。。。。。。。。省略很多代码。。。。。。。。。。。。。
 public void add(int index, E element) {
        if (index<0 || index>size)
            throw new IndexOutOfBoundsException();
        checkForComodification();
        l.add(index+offset, element);
        expectedModCount = l.modCount;
        size++;
        modCount++;
    }

    public E remove(int index) {
        rangeCheck(index);
        checkForComodification();
        E result = l.remove(index+offset);
        expectedModCount = l.modCount;
        size--;
        modCount++;
        return result;
    }

}
}

 

分析上面的源代码：

 

   通过看API AbstractList.class 发现该类里面有一个成员变量： protected transient int modCount = 0， 是不可被序列化的变量，当对集合
进行add,remove,removeRange,addAll等修改动作的时候，每修改一次,modCount加1。用来记录对集合修改的次数。
private class Itr 类里面有一个成员变量expectedModCount，初始值和List中的modCount一样，只要在迭代的过程中线程没有对List集合进行
上面的修改动作，modCount值就不会变。那么expectedModCount=modCount条件始终成立，checkForComodification检测集合是否被修改的
方法里面的if判断不成立，不会抛出异常。
   但是在我们的程序中，执行到list.remove(s);时候，一个线程对集合进行it.next()遍历，一个线程对集合进行remove动作，这样当删除"abc2"对象后，
list对象的成员变量modCount的值+1，但是迭代对象Itr 里面的expectedModCount不变，所以两个值不相等，等再次调用next()方法后，
调用checkForComodification方法，if条件成立，这样就抛出了异常。