在以下四种遍历过程中,前两种会抛出ConcurrentModificationException,而后两种方法是正确的.
Department类:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Department {
private String name;
private List<Member> memberSheet;
public Department(String name) {
this.name = name;
}
public void addMemer(Member member) {
if (memberSheet == null) {
memberSheet = new ArrayList<Member>();
}
memberSheet.add(member);
}
public void printMemberSheet() {
System.out.println("----部门" + name + "人员名单---");
for (Member member : memberSheet) {
System.out.println(member);
}
}
/**
* 里面的四个清除过程请分别独立执行
*
*/
public void removeYoungerFromMemberSheet() {
// 遍历一:这个处理会抛出java.util.ConcurrentModificationException
for (Member member : memberSheet) {
if (member.getAge() < 30) {
memberSheet.remove(member);
}
}
// 遍历二:这个处理也会抛出java.util.ConcurrentModificationException
for (Iterator it = memberSheet.iterator(); it.hasNext();) {
Member member = (Member) it.next();
if (member.getAge() < 30) {
memberSheet.remove(member);
}
}
// 遍历三:这个处理调用Iterator 本身的方法 remove(),会正常执行
for (Iterator it = memberSheet.iterator(); it.hasNext();) {
Member member = (Member) it.next();
if (member.getAge() < 30) {
it.remove();
}
}
// 遍历四:这个处理不依赖Iterator,也会正常执行
for (int i = membeerSheet.size() - 1;i >= 0; i--) {
Member member = memberSheet.get(i);
if (member.getAge() < 30) {
memberSheet.remove(member);
}
}
public String toString() {
return name;
}
public String getName() {
return name;
}
public static void main(String[] args) {
Department resarchDept = new Department("研发部门");
resarchDept.addMemer(new Member("张三", 38));
resarchDept.addMemer(new Member("李四", 24));
resarchDept.addMemer(new Member("王五", 30));
resarchDept.addMemer(new Member("钱七", 22));
resarchDept.addMemer(new Member("孙八", 39));
resarchDept.addMemer(new Member("周九", 30));
resarchDept.removeYoungerFromMemberSheet();
resarchDept.printMemberSheet();
}
}
Member类:
public class Member{
private String name;
private int age;
private Department department;
public Member(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){
StringBuffer sb=new StringBuffer();
sb.append("员工名="+name);
sb.append(" 年龄="+age);
if(department!=null){
sb.append(" 所属部门="+department);
}
return sb.toString();
}
public void changeNewDepartment(Department newDepartment) {
department.removeMemer(name);
newDepartment.addMemer(this);
}
public String getName() {
return name;
}
public void setDepartment(Department department) {
this.department = department;
}
}
同样使用for(Object o:list)遍历时，对遍历出来的对象进行add/remove都会出现ConcurrentModificationException。
由于含有 foreach 循环，对于 List 来说 foreach 循环编译之后会变成类似于这样的代码：
for(Iterator<E> i = list.iterator(); i.hasNext(); );
这里使用到了迭代器，对于 Vector 来说，iterator 方法是使用父类 AbstractList 中的，迭代器并没有同步，因此是线程不安全的，在迭代的时候如果集合数量有增加或者减少都会即可感知到，并抛出 ConcurrentModificationException 异常。
对于 Collections 的 synchronizedCollection 或者 synchronizedList 方法包装过的集合来说，对
于 iterator() 方法是需要用户手工进行同步的，详见 Collections.synchronizedCollection 方法
的 API 文档。
为什么会发生这样的结果呢?这是因为
"当使用 fail-fast iterator 对 Collection 或 Map 进行迭代操作过程中尝试直接修改 Collection / Map 的内容时，即使是在单线程下运行， java.util.ConcurrentModificationException 异常也将被抛出。
Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。"
java.util包中很多迭代器都是所谓的fail-fast迭代器.这些迭代器如果发现集合被修改,而且不是通过迭代器本身,那么抛出一个异常进行清除-ConcurrentModificationException-从而避免不安全行为的发生.
在单线程中，解决这个问题：
1、在单线程代码中如果通过Iterator.remove来删除时，不会抛出ConcurrentModificationException，如果直接从容器中删除的话就会抛出了。
2、在iterator迭代位置增加synchronized(容器);
因此,第三种采用it.remove();不会出现任何异常,而第四不依赖于Iterator而依赖于索引当然更不会出现异常.但这只是在单线程环境，
如果是多线程环境下，还是会存在上述问题。
要在多线程环境中解决这一问题：
1、使用克隆容器，并在副本上进行迭代。由于克隆过程中需要加锁，存在显著的性能开销，这个方式取决于容器的大小，每个元素上执行的操作，迭代操作相对于容器其他操作的调用频率，以及在响应时间和吞吐量等方面的要求；
2、就需要使用 java.util.concurrent 中的任何集合都是经过精心设计的，无论迭代、增加、删除都是线程而全的，而且在迭代时不会抛了 ConcurrentModificationException 的异常。ConcurrentHaspMap、CopyOnWriteArrayList。
ConcurrentHaspMap：同步容器类在执行每个操作期间都持有一个锁，与HashMap一样，也是基于散列的Map，但它使用了一种完全不同的加锁策略来提供更高的并发性和伸缩性。ConcurrentHashMap和其他并发容器类一起增强了同步容器类：它们提供的迭代器不会抛出ConcurrentModificationException，因此不需要再迭代过程中队容器加锁。
CopyOnWriteArrayList：用于替代同步List,在某些情况下提供了更好的并发性能，并且在迭代期间不需要对容器进行加锁或复制。（雷似的，CopyOnWriteArraySet的作用是替代同步Set）。“写入时复制（Copy-On—Write）“容器的线程安全性在于，只要正确的发布一个事实不可变的对象，那么在访问该对象时就不再需要进一步的同步。在每次修改时，都会创建并重新发布一个新的容器副本，从而实现可变性。”写入时复制“容器的迭代器保留一个指向底层基础数组的引用。这个数组当前位于迭代器的起始位置，由于它不会被修改，因此 在对其进行同步时只需要确保数组内容的可见性。因此，多个线程可以同时对这个容器进行迭代，而不会彼此干扰或者与修改容器的线程相互干扰。
显然，每当修改容器时都会复制底层数组，这需要一定的开销，特别是当容器的规模较大时，仅当迭代操作远远多于修改操作时，才应该用”写入时复制“容器。这个准则很好地描述了许多事件通知系统：在分发通知时需要迭代已注册监听器链表，并调用每一个监听器，在大多数情况下，注册和注销事件监听器的操作远少于接收事件通知的操作。