解决:在Java开发过程中，使用iterator遍历集合的同时对集合进行修改就会现,java.util.ConcurrentModificationException异常

解决:在Java开发过程中，使用iterator遍历集合的同时对集合进行修改就会现,java.util.ConcurrentModificationException异常

错误的代码:

public void test1 {
            ArrayList<Integer> arrayList = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                arrayList.add(Integer.valueOf(i));
            }
            Iterator<Integer> iterator = arrayList.iterator();
            while (iterator.hasNext()) {
                Integer integer = iterator.next();
                if (integer.intValue() == 3) {
                    arrayList.remove(integer);  
                }
         }
    }

主要原因是: (借鉴网上说法)Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。
Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变。当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出java.util.ConcurrentModificationException 异常。所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

解决方法:
1)单线程情况下

public void test2 {
            ArrayList<Integer> arrayList = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                arrayList.add(Integer.valueOf(i));
            }
            Iterator<Integer> iterator = arrayList.iterator();
            while (iterator.hasNext()) {
                Integer integer = iterator.next();
                if (integer.intValue() == 3) {
                  //  arrayList.remove(integer);  
                  iterator.remove();  //改用iterator 自带的remove()方法
                }
         }
    }

原因分析:
在iterator.remove()方法中，同样调用了ArrayList自身的remove方法，但是调用完之后并非就return了，而是expectedModCount = modCount重置了expectedModCount值，使二者的值继续保持相等。
针对forEach循环并没有修复方案，因此在遍历过程中同时需要修改ArrayList对象，则需要采用iterator遍历。

问题又来了
上面提出的解决方案调用的是iterator.remove()方法，如果不仅仅是想调用remove方法移除元素，还想增加元素，或者替换元素，是否可以呢？
浏览Iterator源码可以发现这是不行的，Iterator只提供了remove方法。但是ArrayList实现了ListIterator接口，ListIterator类继承了Iter，这些操作都是可以实现的，使用示例如下

        public void test3 {
            ArrayList<Integer> arrayList = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                arrayList.add(Integer.valueOf(i));
            }
            Iterator<Integer> iterator = arrayList.iterator();
            while (iterator.hasNext()) {
                Integer integer = iterator.next();
                if (integer.intValue() == 3) {
                iterator.set( Integer. ValueOf(6) );  //修改
                  iterator.remove();  //改用iterator 自带的remove()方法
                  iterator.add(  integer )
                }
         }
    }

多线程的情况下:

public void test4() {
          ArrayList<Integer> arrayList = new ArrayList<>();
          for (int i = 0; i < 10; i++) {
              arrayList.add(Integer.valueOf(i));
          }
  
          Thread thread1 = new Thread(new Runnable() {
              @Override
              public void run() {
                 ListIterator<Integer> iterator = arrayList.listIterator();
                 while (iterator.hasNext()) {
                     System.out.println("thread1 " + iterator.next().intValue());
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         });
 
         Thread thread2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 ListIterator<Integer> iterator = arrayList.listIterator();
                 while (iterator.hasNext()) {
                    System.out.println("thread2 " + iterator.next().intValue());
                     iterator.remove();                 }
             }
         });
         thread1.start();
         thread2.start();
     }

结果分析:
thread2 遍历结束后，thread1 sleep完1000ms准备遍历第二个元素，next的时候抛出异常了.
两个thread，每个thread都有自己的iterator，当thread2通过iterator方法修改expectedModCount必定不会被thread1感知到。这个跟ArrayList非线程安全是无关的，即使这里面的ArrayList换成Vector也是一样的结果

多线程下的解决方案
方案一：iterator遍历过程加同步锁，锁住整个arrayList
只展示片段代码:

 Thread thread1 = new Thread(new Runnable() {
              @Override
              public void run() {
                 synchronized (arrayList) {
                    ListIterator<Integer> iterator = arrayList.listIterator();
                     while (iterator.hasNext()) {
                         System.out.println("thread1 " + iterator.next().intValue());
                         try {
                             Thread.sleep(100);
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                        }
                     }
                 }
             }
        });

分析:这种方式本质是通过对ArrayList加锁的方式,把多线程转换成单线程操作,确保同一时间内只有一个线程能够使用到iterator ,其他的线程等待,效率显然只有单线程的效率.
方案二：使用CopyOnWriteArrayList，有坑！要明白原理再用

核心代码:
 public void test6() {
         List<Integer> list = new CopyOnWriteArrayList<>();
          for (int i = 0; i < 20; i++) {
              list.add(Integer.valueOf(i));
         }
    }

原理分析:
private transient volatile Object[] array;
CopyOnWriteArrayList本质上是对array数组的一个封装，一旦CopyOnWriteArrayList对象发生任何的修改都会new一个新的Object[]数组newElement，在newElement数组上执行修改操作，修改完成后将newElement赋值给array数组（array=newElement）。因为array是volatile的，因此它的修改对所有线程都可见