`
Disney2002
  • 浏览: 53930 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

再遇 java.util.ConcurrentModificationException

阅读更多
今天又一次遇到java.util.ConcurrentModificationException的异常, 对一个Collection / Map进行遍历或者迭代遍历, 并删除一些符合条件的值时容易出现.

很早的时候自己直接使用的是遍历, 基本上每次都会出现这个问题,后经朋友点拨,这里应该用迭代遍历,就不会出现ConcurrentModificationException, 果然很久没出现了,不过今天又一次遇到这个问题,并且是在迭代遍历的情况下,于是决定彻底解决此问题,不能再次出现了,好好找找原因,弄个明白,下面部分内容参考自网上网友的帖子.

Iterator<MonthlyStatData> it = papers.iterator();
        while (it.hasNext()) {
            MonthlyStatData data = it.next();
            if (data.getValue == 0 ) {
                papers.remove(data);
            }
        }


上面的代码是说有个月统计的List, 里面有部分统计数据是0, 不想让出现,于是就迭代遍历,删除统计数据是0的数据. 但是上面的代码会导致ConcurrentModificationException, 正确的应该是:

Iterator<MonthlyStatData> it = papers.iterator();
        while (it.hasNext()) {
            MonthlyStatData data = it.next();
            if (data.getValue == 0 ) {
                it.remove();
            }
        }


我们从代码中分析问题:
1.Iterator接口
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

2.Collection接口
public interface Collection<E> extends Iterable<E> {
    ...
    Iterator<E> iterator();
    boolean add(E o);
    boolean remove(Object o);
    ...
}

上面两个接口中都含有remove方法, 接着我们看AbstractList
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { 
    protected transient int modCount = 0;
    private class Itr implements Iterator<E> {
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

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

        public E next() {
            checkForComodification();  //特别注意这个方法
            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);  //执行remove对象的操作
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;  //重新设置了expectedModCount的值,避免了ConcurrentModificationException的产生
            } catch(IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)  //当expectedModCount和modCount不相等时,就抛出ConcurrentModificationException
                throw new ConcurrentModificationException();
        }
    }   
}

接着看看ArrayList里面的Remove方法:
public boolean remove(Object o) {
	if (o == null) {
            for (int index = 0; index < size; index++)
		if (elementData[index] == null) {
		    fastRemove(index);
		    return true;
		}
	} else {
	    for (int index = 0; index < size; index++)
		if (o.equals(elementData[index])) {
		    fastRemove(index);
		    return true;
		}
        }
	return false;
    }

    /*
     * Private remove method that skips bounds checking and does not
     * return the value removed.
     */
    private void fastRemove(int index) {
        modCount++; //注意这里,只增加了modCount
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work
    }


看上面的代码,可以了解到产生ConcurrentModificationException的原因就是:
执行remove(Object o)方法之后,modCount和expectedModCount不相等了。然后当代码执行到next()方法时,判断了checkForComodification(),发现两个数值不等,就抛出了该Exception, 要避免这个Exception,就应该使用remove()方法。

转帖另外一个关于此问题描述:ConcurrentModificationException主要原因及处理方法
引用

当使用 fail-fast iterator 对 Collection 或 Map 进行迭代操作过程中尝试直接修改 Collection / Map 的内容时,即使是在单线程下运行,   java.util.ConcurrentModificationException 异常也将被抛出。

  Iterator 是工作在一个独立的线程中,并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

  所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象, Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

  有意思的是如果你的 Collection / Map 对象实际只有一个元素的时候, ConcurrentModificationException 异常并不会被抛出。这也就是为什么在 javadoc 里面指出: it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.

1 import java.util.*;
2
3 public final class MyTest
4 {
5     private static HashMap p_mapList = new HashMap(2);
6     private MyTest(){}
7     public static void init(){
8         // If only there are more than one element in Map,
9         // the ConcurrentModificationException will not be
10         // thrown.
11          p_mapList.put(new String("hello"),new String("world"));
12          p_mapList.put(new String("goto"),new String("hell"));
13      }
14     public static void clear() throws Exception{
15          Iterator pTmpKeys = null;
16          Long pTmpKeyLong;
17          pTmpKeys = p_mapList.keySet().iterator();
18          String pCurKey = null;
19          String pCurObj = null;
20         while(pTmpKeys.hasNext()){
21              pCurKey = (String) pTmpKeys.next();
22              pCurObj = (String) p_mapList.get(pCurKey);
23
24              p_mapList.put(pCurKey,null);
25             // You can not remove element in Map object directly.
26             //p_mapList.remove(pCurKey);
27             // But you can remove current element by iterator itself.
28              pTmpKeys.remove();
29
30              System.out.println(pCurKey + " removed.");
31          }
32          System.out.println(p_mapList.size() + 
33                             " entries left after iterator.");
34          pTmpKeys = null;
35      }
36     public static void main(String[] args)
37                                  throws Exception{
38          MyTest.init();
39          MyTest.clear();
40      }
41 } 


还有一个Sun社区的对Iterator的深入分析:

引用

http://gceclub.sun.com.cn/yuanchuang/week-14/iterator.html
0
1
分享到:
评论

相关推荐

    java.util.ConcurrentModificationException 异常问题详解1

    Java.util.ConcurrentModificationException 异常问题详解 ConcurrentModificationException 异常是 Java 中一个常见的异常,它发生在 Iterator 遍历集合时,集合同时被修改引起的异常。在 Java 中,集合类如 ...

    java.util.ConcurrentModificationException 解决方法

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

    出现java.util.ConcurrentModificationException 问题及解决办法

    在Java编程中,`java.util.ConcurrentModificationException` 是一个常见的运行时异常,通常发生在尝试并发修改集合时。这个异常的产生是由于集合类(如HashMap)的非线程安全特性,当你在一个线程中使用迭代器遍历...

    java 集合并发操作出现的异常ConcurrentModificationException

    在Java编程中,`ConcurrentModificationException`是一个常见的运行时异常,主要出现在多线程环境下对集合类(如List、Set、Map等)进行并发修改时。然而,这个异常不仅限于多线程环境,即使在单线程中,如果在遍历...

    Java语言的Util类详细介绍

    Java语言的Util类详细介绍 Java语言的Util类是Java开发中非常重要的一部分,它提供了一系列的类来实现基本的数据结构,如线性表、链表等。这些类均在java.util包中。 Collection接口是Java中最基本的集合接口,一...

    JAVA.BUG模式详解

    使用`synchronized`关键字、`volatile`变量、`java.util.concurrent`包中的工具类等可以有效地管理并发。 四、内存泄漏 Java中的内存泄漏并不像C++那样直接导致资源耗尽,但过度持有对象引用会导致垃圾收集器无法...

    spring-data-mongodb-test:在Collections.synchronizedList或Collections.synchronizedSet上测试spring数据mongodb ConcurrentModificationException

    Spring数据mongodb测试 在Collections.synchronizedList或Collections.synchronizedSet上测试spring数据mongodb ConcurrentModificationException

    jdk 1.6 API 中文版帮助文档

    - `java.util.Iterator`的改进:支持`remove()`操作,避免抛出`ConcurrentModificationException`。 ### 4. 性能优化 JDK 1.6对编译器和垃圾收集器进行了优化,提高了运行效率,例如: - **Server VM的改进**: ...

    Java多线程安全集合

    Java的`java.util.concurrent`包提供了更为高效且专门设计用于并发操作的集合。比如: - `ConcurrentHashMap`:线程安全的哈希映射,比`synchronized Map`性能更好,因为它允许不同部分独立加锁,减少了锁竞争。 ...

    迭代大师的修炼之道:Java中Iterator与增强for循环的深度解析

    import java.util.ArrayList; import java.util.Iterator; public class IteratorExample { public static void main(String[] args) { ArrayList&lt;String&gt; names = new ArrayList(); names.add("Ada Lovelace");...

    多线程中使用Java集合类.doc

    4. 如果需要更复杂的并发控制,可以使用`java.util.concurrent.locks`包下的Lock接口及其实现,如ReentrantLock,配合`tryLock()`方法进行细粒度的锁控制。 总的来说,处理多线程环境中的Java集合类时,开发者需要...

    Java源码分析:深入探讨Iterator模式

    在Java编程语言中,集合框架(`java.util`包)提供了多种容器类来存储对象,如`List`、`Set`和`Map`等。为了遍历这些容器中的元素,Java引入了迭代器模式(Iterator Pattern),这是一种常用的设计模式,它提供了一...

    java8集合源码-zinc-ConcurrentModificationException:锌并发修改异常

    java.util.ConcurrentModificationException: mutation occurred during iteration [error] scala.collection.mutable.MutationTracker$.checkMutations(MutationTracker.scala:43) [error] scala.collection....

    concurrent.rar

    1. **线程安全类**:如`java.util.concurrent.atomic`包中的原子类,如AtomicInteger、AtomicLong等,它们提供了在不使用锁的情况下实现线程安全的操作。还有`java.util.concurrent`包中的`ConcurrentHashMap`,它是...

    java Iterator迭代器的使用

    `Iterator`是Java中的一个接口,位于`java.util`包下。它提供了一种安全的方式来访问集合中的元素,同时允许在遍历过程中删除元素。迭代器的主要方法包括`hasNext()`(检查集合中是否存在下一个元素)、`next()`...

    Java 7编程高级进阶

    `java.util.concurrent.ForkJoinPool`和`java.util.concurrent.RecursiveTask`是其核心类。 7. **非阻塞堆栈跟踪(Non-blocking Stack Traces)** 当线程处于等待状态时,Java 7可以生成不包含阻塞信息的堆栈跟踪...

Global site tag (gtag.js) - Google Analytics