java集合 -- (6)关于集合的ConcurrentModificationException 异常

柔光的暖阳◎ 2022-04-15 00:37 181阅读 0赞

## 一、关于集合中ConcurrentModificationException异常 ##

研究过java集合的人应该经常在集合源码中见到下面这段代码:

if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();

那么为什么会进行这样的处理呢?还有在什么情况下会触发这个异常?

对于ConcurrentModificationException，通过名字应该能猜的出来，这是一个并发修改产生的异常(这里所谓的修改是指新增或删除)。在集合中这是一种fail-fast（快速失败)机制，目的是在产生并发修改异常时主动抛出异常，而不是任其继续运行产生不可测问题。

**两个属性介绍**

modCount：进行修改操作的次数，初始为0。

expectedModCount：期望修改的次数，初始为0

在集合(比如ArrayList)中每次新增或删除都会执行modCount++操作

比如:

public E remove(int index) {
            rangeCheck(index);
            //修改计数加1
            modCount++;
            E oldValue = elementData(index);
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
    
            return oldValue;
        }

而在进行迭代遍历操作，获取迭代器时会将这个修改计数赋值给期望修改次数：

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;
            //....

如果在迭代期间进行集合的新增删除操作，将造成modCount != expectedModCount成立。

对于迭代器iterator,我们都知道它有两个方法hasNext()和next()方法，关于next()方法:

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()方法,那么这个checkForComodification方法又是干什么的呢?

final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }

好吧，这个方法就是本章开头我们提到的那段代码，如果修改计数和期望计数不相等则抛出异常。那么什么时候会产生这种情况呢？上面其实已经提到:

> 如果在迭代期间进行集合的新增删除操作，将造成modCount != expectedModCount成立。

针对这种情况，其实可以细分为两种情况：单线程和多项程

## 二、异常产生情景 ##

### 单线程 ###

当进行迭代时集合进行了修改操作。

例：

public class TestArray {
    
    	public static void main(String[] args){
    		final ArrayList<Integer> list = new ArrayList<Integer>();
    		for(int i=0;i<10;i++){
    			list.add(i);
    		}
    		Iterator<Integer> iterator = list.iterator();
    		while(iterator.hasNext()){
    			Integer val = iterator.next();
    			list.remove(val);
    		}
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FiYzk5Nzk5NTY3NA_size_16_color_FFFFFF_t_70][]

**解决方案**

1、在迭代时不使用集合的删除方法，改用迭代器的删除方法 iterator.remove();

2、使用for循环遍历集合

3、使用线程安全的集合比如CopyOnWriteArrayList

4、...

### 多线程 ###

对于多线程，如果其中有线程在迭代遍历集合，另外还有线程同时在修改集合，那么就会产生上述异常

例如:

public class TestArray {
    
    	public static void main(String[] args){
    		final ArrayList<Integer> list = new ArrayList<Integer>();
    		for(int i=0;i<10;i++){
    			list.add(i);
    		}
    		new Thread(){
    			@Override
    			public void run() {
    				
    				Iterator<Integer> iterator = list.iterator();
    				while(iterator.hasNext()){
    					System.out.println("遍历集合:"+iterator.next());
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    		}.start();
    		new Thread(){
    			@Override
    			public void run() {
    				Iterator<Integer> iterator = list.iterator();
    				while(iterator.hasNext()){
    					Integer value = iterator.next();
    					System.out.println("删除集合:"+value);
    					iterator.remove();
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    				
    			}
    		}.start();
    		
    	}
    }

结果:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FiYzk5Nzk5NTY3NA_size_16_color_FFFFFF_t_70 1][]

上面的例子在多线程情况下，仅使用单线程遍历中进行删除的第1种解决方案使用it.remove()，但是测试得知上面1、2方案依然会产生同样的异常。  
接着来再看一下JavaDoc对java.util.ConcurrentModificationException异常的描述：  
当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。  
说明以上办法在同一个线程执行的时候是没问题的，但是在异步情况下依然可能出现异常。

1.  尝试方案  
    (1) 在所有遍历增删地方都加上synchronized或者使用Collections.synchronizedList，虽然能解决问题但是并不推荐，因为增删造成的同步锁可能会阻塞遍历操作。  
    (2) 推荐使用ConcurrentHashMap或者CopyOnWriteArrayList。

以上仅个人理解，如有错误望指正。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FiYzk5Nzk5NTY3NA_size_16_color_FFFFFF_t_70]: /images/20220415/976e04525cc44ab68b6f8c7bb9558101.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FiYzk5Nzk5NTY3NA_size_16_color_FFFFFF_t_70 1]: /images/20220415/65a2d686075b4cd6b2cbc7d4579a3c20.png