本想翻译一下java.util.ConcurrentModificationException这篇文章的。但发现讲的不够详细深入,查了一些资料后决定自己扩展一下。水平有限,仅仅作为一个学习总结啦。
异常产生
当我们迭代一个的的ArrayList或者HashMap的中时,如果尝试对集合做一些修改操作(例如删除元素),可能会抛出java.util.ConcurrentModificationException
的异常。
import java.util.Iterator;
import java.util.List;
public class AddRemoveListElement {
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
for (String s : list) {
if (s.equals("B")) {
list.remove(s);
}
}
//foreach循环等效于迭代器
/*Iterator<String> iterator=list.iterator();
while(iterator.hasNext()){
String s=iterator.next();
if (s.equals("B")) {
list.remove(s);
}
}*/
}
}
输出:
![](http://upload-images.jianshu.io/upload_images/1529069-7c55ae4fbbb6e883.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/553)
异常原因
ArrayList的中的父类AbstarctList中有一个域modCount
,每次对集合进行修改(增添元素,删除元素......)时都会modCount++
而的foreach的背后实现原理其实就是迭代器(迭代器关于可以看的Java设计模式:迭代器),等同于注释部分代码在这里,迭代ArrayList中的迭代器中有一个变量expectedModCount
,变量该会modCount
初始化状语从句:相等,但如果接下来如果集合进行修改modCount
改变,就会造成expectedModCount!=modCount
,此时就会抛出java.util.ConcurrentModificationException异常
过程如下图:
![](http://upload-images.jianshu.io/upload_images/1529069-2523e3564181c304.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
我们再来根据源码详细的走一遍这个过程
/*
*AbstarctList的内部类,用于迭代
*/
private class Itr implements Iterator<E> {
int cursor = 0; //将要访问的元素的索引
int lastRet = -1; //上一个访问元素的索引
int expectedModCount = modCount;//expectedModCount为预期修改值,初始化等于modCount(AbstractList类中的一个成员变量)
//判断是否还有下一个元素
public boolean hasNext() {
return cursor != size();
}
//取出下一个元素
public E next() {
checkForComodification(); //关键的一行代码,判断expectedModCount和modCount是否相等
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();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
根据代码可知,每次迭代列表时,会初始化ITR的三个成员变量
int cursor = 0; //将要访问的元素的索引
int lastRet = -1; //上一个访问元素的索引
int expectedModCount = modCount; //预期修改值,初始化等于modCount(AbstractList类中的一个成员变量)
接着调用hasNext()
循环判断访问元素的下标是否到达末尾。如果没有,调用next()
方法,取出元素。
而最上面测试代码出现异常的原因在于,next()
方法调用checkForComodification()
时,发现了modCount != expectedModCount
接下来我们看下ArrayList中的源码,了解下modCount的是如何与expectedModCount不相等的。
public boolean add(E paramE) {
ensureCapacityInternal(this.size + 1);
/** 省略此处代码 */
}
private void ensureCapacityInternal(int paramInt) {
if (this.elementData == EMPTY_ELEMENTDATA)
paramInt = Math.max(10, paramInt);
ensureExplicitCapacity(paramInt);
}
private void ensureExplicitCapacity(int paramInt) {
this.modCount += 1; //修改modCount
/** 省略此处代码 */
}
public boolean remove(Object paramObject) {
int i;
if (paramObject == null)
for (i = 0; i < this.size; ++i) {
if (this.elementData[i] != null)
continue;
fastRemove(i);
return true;
}
else
for (i = 0; i < this.size; ++i) {
if (!(paramObject.equals(this.elementData[i])))
continue;
fastRemove(i);
return true;
}
return false;
}
private void fastRemove(int paramInt) {
this.modCount += 1; //修改modCount
/** 省略此处代码 */
}
public void clear() {
this.modCount += 1; //修改modCount
/** 省略此处代码 */
}
从上面的代码可以看出,ArrayList的中的添加,删除,清除方法都会造成modCount的的的改变。迭代过程中如何调用这些方法就会造成modCount的的的增加,使迭代类中expectedModCount和modCount的的不相等。
异常的解决
1.单线程环境
好,现在我们已经基本了解了异常的发送原因了。接下来我们来解决它。
我很任性,我就是想在迭代集合时删除集合的元素,怎么办?
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
String str = iter.next();
if( str.equals("B") )
{
iter.remove();
}
}
细心的朋友会发现ITR中的也有一个删除方法,实质也是调用了ArrayList中的中的删除,但增加了expectedModCount = modCount;
保证了不会抛出java.util.ConcurrentModificationException异常。
但是,这个办法的有两个弊端
1.只能进行删除操作,添加,清晰等ITR中没有
0.2。而且只适用单线程环境。
2.多线程环境
在多线程环境下,我们再次试验下上面的代码
public class Test2 {
static List<String> list = new ArrayList<String>();
public static void main(String[] args) {
list.add("a");
list.add("b");
list.add("c");
list.add("d");
new Thread() {
public void run() {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(Thread.currentThread().getName() + ":"
+ iterator.next());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
}.start();
new Thread() {
public synchronized void run() {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(Thread.currentThread().getName() + ":"
+ element);
if (element.equals("c")) {
iterator.remove();
}
}
};
}.start();
}
}
输出:
![](http://upload-images.jianshu.io/upload_images/1529069-115efcc899714ab2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/681)
异常的原因很简单,一个线程修改了列表的modCount的的导致另外一个线程迭代时modCount的的与该迭代器的expectedModCount不相等。
此时有两个办法:
- 迭代前加锁,解决了多线程问题,但还是不能进行迭代添加,清晰等操作
public class Test2 {
static List<String> list = new ArrayList<String>();
public static void main(String[] args) {
list.add("a");
list.add("b");
list.add("c");
list.add("d");
new Thread() {
public void run() {
Iterator<String> iterator = list.iterator();
synchronized (list) {
while (iterator.hasNext()) {
System.out.println(Thread.currentThread().getName()
+ ":" + iterator.next());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
}.start();
new Thread() {
public synchronized void run() {
Iterator<String> iterator = list.iterator();
synchronized (list) {
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(Thread.currentThread().getName()
+ ":" + element);
if (element.equals("c")) {
iterator.remove();
}
}
}
};
}.start();
}
}
- 采用的的CopyOnWriteArrayList,解决了多线程问题,同时可以添加,清晰等操作
public class Test2 {
static List<String> list = new CopyOnWriteArrayList<String>();
public static void main(String[] args) {
list.add("a");
list.add("b");
list.add("c");
list.add("d");
new Thread() {
public void run() {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(Thread.currentThread().getName()
+ ":" + iterator.next());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
}.start();
new Thread() {
public synchronized void run() {
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(Thread.currentThread().getName()
+ ":" + element);
if (element.equals("c")) {
list.remove(element);
}
}
};
}.start();
}
}
的的CopyOnWriteArrayList也是一个线程安全的的ArrayList中,其实现原理在于,每次添加,删除等所有的操作都是重新创建一个新的数组,再把引用指向新的数组。
由于我用的的CopyOnWriteArrayList少,这里就不用讨论了,想了解可以看:Java并发编程:并发容器之间CopyOnWriteArrayList
深入理解异常-fail快速机制
到这里,我们似乎已经理解完这个异常的产生缘由了。
但是,仔细思考,还是会有几点疑惑:
- 既然modCount的的与expectedModCount不同会产生异常,那为什么还设置这个变量
- ConcurrentModificationException的的可以翻译成“并发修改异常”,那这个异常是否与多线程有关呢?
我们来看看源码中modCount的的的注解
/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
*
* <p>This field is used by the iterator and list iterator implementation
* returned by the {@code iterator} and {@code listIterator} methods.
* If the value of this field changes unexpectedly, the iterator (or list
* iterator) will throw a {@code ConcurrentModificationException} in
* response to the {@code next}, {@code remove}, {@code previous},
* {@code set} or {@code add} operations. This provides
* <i>fail-fast</i> behavior, rather than non-deterministic behavior in
* the face of concurrent modification during iteration.
*
* <p><b>Use of this field by subclasses is optional.</b> If a subclass
* wishes to provide fail-fast iterators (and list iterators), then it
* merely has to increment this field in its {@code add(int, E)} and
* {@code remove(int)} methods (and any other methods that it overrides
* that result in structural modifications to the list). A single call to
* {@code add(int, E)} or {@code remove(int)} must add no more than
* one to this field, or the iterators (and list iterators) will throw
* bogus {@code ConcurrentModificationExceptions}. If an implementation
* does not wish to provide fail-fast iterators, this field may be
* ignored.
*/
protected transient int modCount = 0;
我们注意到,注解中的频繁出现了fail-fast
那么fail-fast
(快速失败)机制是什么呢?
“快速失败”也就是快速失败的,它是Java的的集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时,有可能会产生快速失败的机制。记住是有可能,而不是一定例如:假设存在两个线程(线程1,线程2),线程1通过迭代在遍历集合甲中的元素,在某个时候线程2修改了集合甲的结构(是结构上面的修改,而不是简单的修改集合元素的内容),那么这个时候程序就会抛出ConcurrentModificationException的异常,从而产生快速失败的机制。
看到这里,我们明白了,快速失败的机制就是为了防止多线程修改集合造成并发问题的机制嘛。
之所以有modCount的的这个成员变量,就是为了辨别多线程修改集合时出现的错误。而爪哇。 UTIL中.ConcurrentModificationException就是并发异常。
但是单线程使用不单时也可能抛出这个异常。
作者:MrDTree
链接:HTTPS://www.jianshu.com/p/c5b52927a61a
来源:简书
。著作权归作者所有商业转载请联系作者获得授权,非商业转载请注明出处。