java.util.ConcurrentModificationException迭代器出错

问题

最近在一次代码保守中，遇到了这样一个问题：java.util.ConcurrentModificationException。调查出的结果是ArrayList在迭代的时候如果同时对其进行修改就会抛出Java.util.ConcurrentModificationException异常。
比如以下情况：

        Iterator<Integer> iterator = list.iterator();        while (iterator.hasNext()) {            Integer integer = iterator.next();            if (integer == 2)                list.remove(integer);        }        // 或者        for(int i : list){......}

使用迭代器遍历的时候，如果遇到2，就删除这个元素，会立刻抛错ConcurrentModificationException。

调查：

查看ArrayList的源码，发现抛错的573行确实是 throw new ConcurrentModificationException();而导致这个错误的原因是ourList.modCount != expectedModCount
代码在遍历的时候，使用的list的iterator方法：

    @Override public Iterator<E> iterator() {        return new ArrayListIterator();    }

返回了一个ArrayListIterator。

private class ArrayListIterator implements Iterator<E> {        ......        /** The expected modCount value */        private int expectedModCount = modCount;        ......        @SuppressWarnings("unchecked") public E next() {            ArrayList<E> ourList = ArrayList.this;            int rem = remaining;            if (ourList.modCount != expectedModCount) {                throw new ConcurrentModificationException();// 573行            }            if (rem == 0) {                throw new NoSuchElementException();            }            remaining = rem - 1;            return (E) ourList.array[removalIndex = ourList.size - rem];        }        ......}

从上述源码可知，ArrayListIterator是ArrayList的内部类，expectedModCount是ArrayListIterator的一个成员变量，modCount是ArrayList的成员变量。expectedModCount初始值和modCount相同，那么为什么会不一样呢。
查看ArrayList的add函数：

    @Override public boolean add(E object) {        Object[] a = array;        int s = size;        if (s == a.length) {            Object[] newArray = new Object[s +                    (s < (MIN_CAPACITY_INCREMENT / 2) ?                     MIN_CAPACITY_INCREMENT : s >> 1)];            System.arraycopy(a, 0, newArray, 0, s);            array = a = newArray;        }        a[s] = object;        size = s + 1;        modCount++;        return true;    }

发现ArrayList在进行add和remove操作的时候会对modCount进行++，那么如果此时同时使用迭代器进行遍历的话，ArrayList中的modCount和ArrayListIterator中的expectedModCount，一定不会相等。
在观察一下ArrayListIterator自己的remove方法：

        public void remove() {            Object[] a = array;            int removalIdx = removalIndex;            if (modCount != expectedModCount) {                throw new ConcurrentModificationException();            }            if (removalIdx < 0) {                throw new IllegalStateException();            }            System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);            a[--size] = null;  // Prevent memory leak            removalIndex = -1;            expectedModCount = ++modCount;        }

代码中在最后对expectedModCount和modCount进行了同步，所以如果在单线程的状态下，迭代器的使用和remove操作同时进行的时候，可以使用迭代器自己的remove方法解决这个问题。

单线程解决方案：

代码如下：

        Iterator<Integer> iterator = list.iterator();        while (iterator.hasNext()) {            Integer integer = iterator.next();            if (integer == 2)                iterator.remove();        }

很可惜迭代器没有add方法，所以如果同步解决的是添加的操作，好像无解了？

多线程解决方案

那么add操作或者是多进程怎么办呢，根据上面的源码，ArrayList在调用iterator返回迭代器的时候，返回的是一个new ArrayListIterator();那就意味着，两个线程，所获取的ArrayListIterator不一样，他们的expectedModCount也是分开的，一旦其中一个线程进行了操作，修改了modCount，即便我们使用迭代器自己的remove方法，同步了线程1的expectedModCount和modCount，线程2的expectedModCount还是会和modCount不一致的。

所以有一个最直接的方式，不用迭代器，比如我们这次遇到的问题，可以把

for (int i : lists)

改为

for (int i = 0; i < lists.size();  i++)

当然如果一定要使用迭代器，网上给出了两个方案：

1. 在迭代时使用synchronized或者Lock进行同步
2. 使用CopyOnWriteArrayList替代ArrayList。
   CopyOnWriteArrayList是一种写时copy的方案，在需要修改的时候复制一个副本，并锁住内容，避免多个副本生成，修改完成之后将引用指向新的副本。所以会带来两个问题，一个是副本生成时的内存消耗，一个是不能及时反映修改，只能保证最终结果的一致性。
   以下是尝试代码：

        new Thread(new Runnable() {            @Override            public void run() {                Iterator<Integer> iterator = list.iterator();                while (iterator.hasNext()) {                    Integer integer = iterator.next();                    if (integer % 2 == 0)                        list.remove(integer);                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println("result:");                for (int i = 0; i < list.size(); i++) {                    System.out.print(list.get(i));                }            }        }).start();        new Thread(new Runnable() {            @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();