多线程14-遍历集合时删除元素问题分析

1. 问题

创建一个User类：

package cn.itcast.heima2;
public class User implements Cloneable{
private String name;
private int age;

public User(String name, int age) {
this.name = name;
this.age = age;
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(!(obj instanceof User)) {
return false;
}
User user = (User)obj;
//if(this.name==user.name && this.age==user.age)
if(this.name.equals(user.name)
&& this.age==user.age) {
return true;
}
else {
return false;
}
}
public int hashCode() {
return name.hashCode() + age;
}

public String toString() {
return "{name:'" + name + "',age:" + age + "}";
}
public Object clone()  {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException e) {}
return object;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
}

执行下面的代码　：

package cn.itcast.heima2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
public class CollectionModifyExceptionTest {
public static void main(String[] args) {
Collection<User> users  = new ArrayList<User>() ;
users.add(new User("张三",28));
users.add(new User("李四",25));
users.add(new User("王五",31));
Iterator<User> itrUsers = users.iterator();

while(itrUsers.hasNext()){
System.out.println("aaaa");
User user = (User)itrUsers.next();
if("张三".equals(user.getName())){
users.remove(user);
//itrUsers.remove();
} else {
System.out.println(user);
}
}
}
}

在遍历集合的时候如果查找到“张三” 则将张三的信息给删除了 代码初一看没有问题 ，但是一执行结果如下：

aaaa
aaaa
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
at java.util.ArrayList$Itr.next(Unknown Source)
at cn.itcast.heima2.CollectionModifyExceptionTest.main(CollectionModifyExceptionTest.java:17)

出现了异常　　这是为什么呢？

2. 分析问题：

要想得到这个答案 需要去查看代码的执行过程

首先看

Iterator<User> itrUsers = users.iterator();

中的 users.iterator()调用的是ArrayList中的iterator方法 ，其源码为：

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

返回的是 new Itr() ;其中Itr是ArrayList中的一个内部类　代码如下：

private class Itr implements Iterator<E> {
int cursor;       // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;

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

@SuppressWarnings("unchecked")
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];
}

public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

那么上面对iterator的遍历操作都是通过Itr中实现的

程序中的itrUsers.hasNext() 调用的为Itr中的hasNext()方法

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

　　其中的size 表示的是users集合的长度：size = 3 ； cursor 是int类型 默认值为0 那么第一次执行hasNext 的时候显然 cursor != size 返回true

然后看itrUsers.next()这段代码 执行的为：

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];
}

该段代码首先要执行checkForComodification()方法 其代码为：

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

其中modCount 为父类AbstractList中定义的protetct变量 初始为0 ; int expectedModCount = modCount; 开始两者是一致的 ， 然后cursor = i + 1 ; 即cursor=1 ;

接下来代码可以执行到：

if("张三".equals(user.getName())){

这里，接下来运行的是：

users.remove(user);

remove的源码为：

public E remove(int index) {
rangeCheck(index);

modCount++;
E oldValue = elementData(index);

int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work

return oldValue;
}

这段代码中要注意的有两个地方 ，其中1个为 modCount++; 即modCount = 1 ； 还有一个是 elementData[--size] = null; 这行代码删除了数组中的一个元素 同时也对size进行了减1操作

即此时 size = 2 ;

经过上述代码以后 张三的信息顺利的从集合中删除了， 接下来需要看是第二次循环：

还是 hasNext() 方法 由于cursor = 1 size = 2 ; 那么hasNext()返回true 成功的进入循环

那么开始执行itrUsers.next() ,需要调用checkForComodification() 方法 ，但是此时 expectedModCount = 0 ， modCount = 1 ； 程序代码会抛出异常

throw new ConcurrentModificationException();

程序代码到此结束。结果为删除张三抛出异常。

3. 探索

如果把代码修改为删除李四，效果是怎么样呢？ 结果如下:

aaaa
{name:'张三',age:28}
aaaa

代码成功执行，没有任何异常

还是按照上面的思路来分析这个问题

size = 3 第一次hasNext 返回true， 执行next() 得到 cursor = 1 ,第一次成功循环结束

开始第二次循环

size = 3 第二次hasNext 返回true ，执行next() 得到cursor = 2 ,发现是要删除李四了 执行remove 方法 此时 size = 2 , modCount = 1 ,成功删除了李四的信息

开始第三次循环

size = 2 第三次hasNext cursor = 2 和size相等 此时 hasNext 返回了false 没有进入循环 ，代码执行结束 ，导致能成功删除李四 没有任何异常.

要想避免上述的问题 即在集合遍历的时候能对集合进行数据的增删操作 需要用到CopyOnWriteArrayList ，将程序修改如下：

package cn.itcast.heima2;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
public class CollectionModifyExceptionTest {
public static void main(String[] args) {
Collection<User> users  = new CopyOnWriteArrayList<User>();
users.add(new User("张三",28));
users.add(new User("李四",25));
users.add(new User("王五",31));
Iterator<User> itrUsers = users.iterator();

while(itrUsers.hasNext()){
System.out.println("aaaa");
User user = (User)itrUsers.next();
if("李四".equals(user.getName())){
users.remove(user);
//itrUsers.remove();
} else {
System.out.println(user);
}
}
}
}

使用CopyOnWriteArrayList能成功的原因是其中 user.iterator()返回的不再是Itr了 ，而是CopyOnWriteArrayList中的COWIterator内部类：

public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}

其中COWIterator代码可自行研究.