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条件成立，这样就抛出了异常。