ConcurrentModificationException异常原因和解决方法

今天药忘吃喽~ 2024-05-23 20:31 91阅读 0赞

## ConcurrentModificationException异常原因和解决方法 ##

### 简介 ###

*  先看一下一个例子举出 ConcurrentModificationException 的出现场景：
 *      public static void main(String[] args) {
            List<Integer> list = new ArrayList<Integer>(){
                {
                    add(1);
                    add(2);
                    add(3);
                }
            };
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()) {
                iterator.next();
                list.add(4);
            }
        }
 *  ConcurrentModificationException 中文意思就是并发修改异常，存在于并发使用 Iterator 时出现的时候，那这个异常是为什么会出现的呢？这个涉及到 fast-fail 机制（快速失败），可以提前预料遍历失败情况，防止数组越界异常，我们看一下源代码：

### ArrayList 源代码 ###

#### ArrayList 类的源代码 ####

*  我们看一下 remove 和 add 方法：
 *      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 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; // clear to let GC do its work
        }
        
        public void add(int index, E element) {
            rangeCheckForAdd(index);
        
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            //拷贝后面的值
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            //添加元素
            elementData[index] = element;
            size++;
        }
        
        private void ensureCapacityInternal(int minCapacity) {
            ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
        }
        
        private static int calculateCapacity(Object[] elementData, int minCapacity) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            return minCapacity;
        }
        
        private void ensureExplicitCapacity(int minCapacity) {
            //修改 modCount 值，变量类似版本
            modCount++;
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }

#### ArrayList 内部类 Itr 的源代码 ####

*      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;
            
            public boolean hasNext() {
                return cursor != size;
            }
        
            @SuppressWarnings("unchecked")
            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];
            }
        
            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
        
                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
        
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
 *  cursor：表示下一个要访问的元素的索引，从next()方法的具体实现就可看出
 *  lastRet：表示上一个访问的元素的索引
 *  expectedModCount：表示对ArrayList修改次数的期望值，它的初始值为modCount。
 *  modCount 是在 ArrayList 中赋值的，并且初始值为 0，在 add 和 remove 的时候（修改元素的时候）会增加 1，
 *  我们看一下 hasNext 方法，在方法中的 size 是 ArrayList 中的变量，这个 ConcurrentModificationException 异常存在的原因之一就在这个方法体现出来了，在多线程的情况下，如果使用迭代器遍历时，ArrayList数组元素变少导致 cursor > size，然后数组越界。
 *      public boolean hasNext() {
            return cursor != size;
        }
 *  在正常情况下当 cursor == size代表已经到数组尽头了。我们再看一下 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];
        }
 *  next 方法中先是判断了 modCount 是否等于 expectedModCount，不相等则抛出 并发修改异常，否则取到游标，然后判断游标是否大于数组长度或者元素个数。最后游标加一，然后返回数的同时使 lastRet 等于 i。我们再看一下 remove 方法：
 *      public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
        
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
 *  其实就是在 remove 掉元素的时候更新下自己的 expectedModCount。注意的是remove后 lastRet 会变成 -1，也就是不能连续 remove 两次，因为在 next 中检查了 lastRet 的值不能小于 0。

### 解决方案 ###

#### 单线程的解决方案： ####

*  使用 Itr 类中也给出的 remove() 方法：因为 Iterator 的 remove 会更新 expectedModCount 的值。
 *      public static void main(String[] args) {
            List<Integer> list = new ArrayList<Integer>(){
                {
                    add(1);
                    add(2);
                    add(3);
                }
            };
            Iterator<Integer> iterator = list.iterator();
        
            while (iterator.hasNext()) {
                iterator.next();
                iterator.remove();
            }
        }

#### 多线程的解决方案： ####

*      private static List<Integer> LIST = new ArrayList<Integer>(){
            {
                add(1);
                add(2);
                add(3);
            }
        };
        public static void main(String[] args) {
        
            new Thread(() -> {
                Iterator<Integer> iterator = LIST.iterator();
        
                while (iterator.hasNext()) {
                    iterator.next();
                    iterator.remove();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        
            new Thread(() -> {
                try {
                    Thread.sleep(400);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                LIST.add(4);
            }).start();
        }
 *  有可能有朋友说ArrayList是非线程安全的容器，换成Vector就没问题了，实际上换成Vector还是会出现这种错误。
 *  原因在于，虽然Vector的方法采用了synchronized进行了同步，但是实际上通过Iterator访问的情况下，每个线程里面返回的是不同的iterator，也即是说expectedModCount是每个线程私有。假若此时有2个线程，线程1在进行遍历，线程2在进行修改，那么很有可能导致线程2修改后导致Vector中的modCount自增了，线程2的expectedModCount也自增了，但是线程1的expectedModCount没有自增，此时线程1遍历时就会出现expectedModCount不等于modCount的情况了。
 *  因此一般有2种解决办法：
 *  在使用iterator迭代的时候使用synchronized或者Lock进行同步；
 *  使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。