命运的红线一旦断了，就再也不会接上。 —— 《犬夜叉》
问题介绍
List如何在增加元素的同时删除元素。
这还不简单？
直接上代码：
List<String> lists = new ArrayList<>();
lists.add("MRyan");
lists.add("MRyan2");
lists.add("MRyan3");
for (String list : lists) {
if (list.equals("MRyan")) {
lists.remove(list);
}
}
System.out.println(lists);
然后兴奋的运行程序，结果发现Exception 。
很惨，报错了，报了如下错误：
Exception in thread "main" java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1012)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:966)
at com.text.text.main(text.java:18)
报错原因及分析源码
发生了什么错误？
java.util.ConcurrentModificationException表示ArrayList在迭代的时候如果同时对其进行修改就会抛出的异常。
也就是说这是一个并发的问题。
那为什么会发生这个错误？
接下来我们来从源码下手：
定位到ArrayList的源码
查看ArrayList的add方法：
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return {@code true} (as specified by {@link Collection#add})
*/
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
首先modCount进行了自增然后调用了自己的private void add（E e, Object[] elementData, int s）方法。
定位到private void add（E e, Object[] elementData, int s）方法
/**
* This helper method split out from add(E) to keep method
* bytecode size under 35 (the -XX:MaxInlineSize default value),
* which helps when add(E) is called in a C1-compiled loop.
*/
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}其实就是首先判断是否需要扩容，然后将值添加到数组中，数组大小加1。
那你会有疑问了，刚才出现的modCount是什么？别着急往下看
定位到remove（Object o）方法：
/**
* Removes the first occurrence of the specified element from this list,
* if it is present. If the list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index
* {@code i} such that
* {@code Objects.equals(o, get(i))}
* (if such an element exists). Returns {@code true} if this list
* contained the specified element (or equivalently, if this list
* changed as a result of the call).
*
* @param o element to be removed from this list, if present
* @return {@code true} if this list contained the specified element
*/
public boolean remove(Object o) {
final Object[] es = elementData;
final int size = this.size;
int i = 0;
found: {
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
} else {
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
fastRemove(es, i);
return true;
}最后调用了fastRemove（Object[] es, int i）方法。
定位到fastRemove（Object[] es, int i）
/**
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
}我们又发现了modCount进行了自增，于是我们得知modCount其实就是修改的次数，add和remove包括clear，addAll等对list元素的操作都会调用它。
现在回到我们代码报错的地方
Exception in thread "main" java.util.ConcurrentModificationException
at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1012)
at java.base/java.util.ArrayList$Itr.next(ArrayList.java:966)
at com.text.text.main(text.java:18)发现checkForComodification处抛出了异常。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
我们发现是因为判断modCount和expectedModCount不相等于是抛出了异常。
那么问题又来了。
expectedModCount是什么？？？
/**
* An optimized version of AbstractList.Itr
*/
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;
// prevent creating a synthetic constructor
Itr() {}
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();
}
}
@Override
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int size = ArrayList.this.size;
int i = cursor;
if (i < size) {
final Object[] es = elementData;
if (i >= es.length)
throw new ConcurrentModificationException();
for (; i < size && modCount == expectedModCount; i++)
action.accept(elementAt(es, i));
// update once at end to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
源码中发现初始化时expectedModCount=modCount
expectedModCount表示的是ArrayList修改次数的期望值
迭代时调用next方法
@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];
}也是先调用checkForComodification（）方法modCount != expectedModCount则抛出异常。
刚才我们发现了remove方法会调用fastRemove方法 之后modCount会进行自增，而expectedModCount没有进行改变，两者不相等则抛出ConcurrentModificationException（）异常。
如何解决此问题
利用Iterator迭代器删除即可
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SubList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = SubList.this.modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
因为Iterator的remove方法会使expectedModCoun和modCount两值相等，自然没问题了。
正确代码：
List<String> lists = new ArrayList<>();
lists.add("MRyan");
lists.add("MRyan2");
lists.add("MRyan3");
Iterator<String> iterator=lists.iterator();
while(iterator.hasNext()){
String list=iterator.next();
if(list.equals("MRyan")){
iterator.remove();
}
}
System.out.println(lists);运行结果：
[MRyan2, MRyan3]
总结
那就是ArrayList 本身不是线程安全的
作者：MRyan
本文采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可。
转载时请注明本文出处及文章链接。本文链接：https://www.wormholestack.com/archives/390/