有关java.util.ConcurrentModificationException


java doc对这个类的定义:

This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible. 



For example, it is not generally permissible for one thread to modify a Collection while another thread is iterating over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator
implementations (including those of all the general purpose collection implementations provided by the JRE) may choose to throw this exception if this behavior is detected. Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly,
rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future. 





Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the
object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will throw this exception. 





Note that fail-fast behavior cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast operations throw ConcurrentModificationException on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.

 产生这个异常的原因:并发改动对象,而对象不支持并发改动。

比較常见的是多线程并发,或者单线程遍历集合的时候同一时候改动集合元素。

比方:
package com.doctor.java8;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; /**
* This program crashes by throwing java.util.ConcurrentModificationException. Why? Because the
* iterators of ArrayList are fail-fast; it fails by throwing ConcurrentModificationException if it detects that
* the underlying container has changed when it is iterating over the elements in the container. This behavior
* is useful in concurrent contexts when one thread modifies the underlying container when another thread is
* iterating over the elements of the container.
*
* @author sdcuike
*
* Created on 2016年3月6日 上午10:24:21
*/
public class ModifyingList { /**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) {
System.out.println(iterator.next());
list.add("three");
} // one
// Exception in thread "main" java.util.ConcurrentModificationException
// at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
// at java.util.ArrayList$Itr.next(ArrayList.java:851)
// at com.doctor.java8.ModifyingList.main(ModifyingList.java:24) } }

CopyOnWriteArrayList

既然普通集合的iterators是fail-fast的即不支持訪问同一时候改动的场景。那我们用并发容器CopyOnWriteArrayList。


package com.doctor.java8;

import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList; /**
* Modifying CopyOnWriteArrayList
*
* Observe that the element “four” added three times is not printed as part of the output. This is because
* the iterator still has access to the original (unmodified) container that had three elements. If you create a
* new iterator and access the elements, you will find that new elements have been added to aList.
*
* @author sdcuike
*
* Created on 2016年3月6日 上午10:32:39
*/
public class ModifyingCopyOnWriteArrayList { /**
* @param args
*/
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
list.add("one");
list.add("two");
list.add("three"); Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) {
System.out.println(iterator.next());
list.add("four");
}
// one
// two
// three
System.out.println("============");
iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// one
// two
// three
// four
// four
// four } }

java.util.concurrent.CopyOnWriteArrayList<E>

A thread-safe variant of java.util.ArrayList in which all mutative operations (add,set, and so on) are implemented by making a fresh copy of
the underlying array.

当对CopyOnWriteArrayList调用改动数据操作方法的时候。会copy一份新的内部数组结构,而对原来的内部数组结构没影响。

假设要訪问新的数据,我们必须又一次获取底层新的数组结构的iterator(见上面的程序)。

有关java.util.ConcurrentModificationException的更多相关文章

  1. java.util.ConcurrentModificationException 解决办法(转载)

    今天在项目的中有一个需求,需要在一个Set类型的集合中删除满足条件的对象,这时想当然地想到直接调用Set的remove(Object o)方法将指定的对象删除即可,测试代码:   public cla ...

  2. java.util.ConcurrentModificationException --map

    key:3-key key:/v1.02-key Exception in thread "main" java.util.ConcurrentModificationExcept ...

  3. 偶遇到 java.util.ConcurrentModificationException 的异常

    今天在调试程序 遇到了如此问题 贴上代码来看看稍后分析 List<String> list = null;boolean isUpdate = false;try { list = JSO ...

  4. 对ArrayList操作时报错java.util.ConcurrentModificationException null

    用iterator遍历集合时要注意的地方:不可以对iterator相关的地方做添加或删除操作.否则会报java.util.ConcurrentModificationException 例如如下代码: ...

  5. LinkedList - java.util.ConcurrentModificationException

    package com.test.io; import java.io.BufferedReader; import java.io.FileNotFoundException; import jav ...

  6. java.util.ConcurrentModificationException 解决办法

    在使用iterator.hasNext()操作迭代器的时候,如果此时迭代的对象发生改变,比如插入了新数据,或者有数据被删除. 则使用会报以下异常:Java.util.ConcurrentModific ...

  7. Iterator之java.util.ConcurrentModificationException

    在运行以下代码时,会报java.util.ConcurrentModificationException异常, public class Demo { public static void main( ...

  8. java.util.ConcurrentModificationException 解决办法(转)

    今天在项目的中有一个需求,需要在一个Set类型的集合中删除满足条件的对象,这时想当然地想到直接调用Set的remove(Object o)方法将指定的对象删除即可,测试代码:   public cla ...

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

    ConcurrentModificationException 异常:并发修改异常,当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常.一个线程对collection集合迭代,另一个线程对Co ...

  10. list删除操作 java.util.ConcurrentModificationException

    首先大家先看一段代码: public static void main(String[] args) { List<String> listStr = new ArrayList<S ...

随机推荐

  1. E - A Trivial Problem(求满足x!的尾数恰好有m个0的所有x)

    Problem description Mr. Santa asks all the great programmers of the world to solve a trivial problem ...

  2. B - Lucky Division

    Problem description Petya loves lucky numbers. Everybody knows that lucky numbers are positive integ ...

  3. .net中的WebForm引人MVC的控制器

    当下.net中比较火的模式MVC模式,说实话对于菜鸟的我还没有遇到一个比较健全的MVC模式的项目也是比较遗憾.偶然间在网上看到WebForm实现MVC中的模式(主要是控制器...)就学习了一波,下面是 ...

  4. MatLab之Simulink之simple model

    Use Simulink to model a system and then simulate the dynamic behavior of that system. 1 Open in Comm ...

  5. VHDL之concurrent之block

    1 Simple BLOCK The simple block represents only a way of partitioning the code. It allows concurrent ...

  6. (转) OpenLayers3基础教程——OL3 介绍control

    http://blog.csdn.net/gisshixisheng/article/details/46761535 概述: 本文讲述的是Ol3中的control的介绍和应用. OL2和OL3 co ...

  7. (转)OpenLayers3基础教程——OL3 介绍interaction

    http://blog.csdn.net/gisshixisheng/article/details/46808647 概述: 本节主要讲述OL3的交互操作interaction,重点介绍draw,s ...

  8. BZOJ 3036: 绿豆蛙的归宿 期望 + 拓扑排序

    随着新版百度空间的下线,Blog宠物绿豆蛙完成了它的使命,去寻找它新的归宿.给出一个有向无环的连通图,起点为1终点为N,每条边都有一个长度.绿豆蛙从起点出发,走向终点. 到达每一个顶点时,如果有K条离 ...

  9. BZOJ 1060: [ZJOI2007]时态同步 树上问题 + 贪心

    Description 小Q在电子工艺实习课上学习焊接电路板.一块电路板由若干个元件组成,我们不妨称之为节点,并将其用数 字1,2,3….进行标号.电路板的各个节点由若干不相交的导线相连接,且对于电路 ...

  10. PAT_A1120#Friend Numbers

    Source: PAT A1120 Friend Numbers (20 分) Description: Two integers are called "friend numbers&qu ...