Java常见异常原因以及解决方案

Java常见异常原因以及解决方案

一、ConcurrentModificationException（转）

此部分引自http://www.2cto.com/kf/201403/286536.html 侵删

单线程

• 异常原因
  在使用迭代器Iterator进行遍历时，进行了remove操作。（其他增删操作也有可能引发该异常）
  以List为例：

List<string> myList = new ArrayList<string>();

myList.add( "1");
myList.add( "2");
myList.add( "3");
myList.add( "4");
myList.add( "5");


/**
* 以下三种遍历方法都会跑出异常
**/
Iterator<string> it = myList.iterator();
 while (it.hasNext()) {
     String value = it.next();
      if (value.equals( "3")) {
          myList.remove(value);  // error
     }
}

 for (Iterator<string> it = myList.iterator(); it.hasNext();) {
     String value = it.next();
      if (value.equals( "3")) {
          myList.remove(value);  // error
     }
}


 for (String value : myList) {
     System. out.println( "List Value:" + value);
      if (value.equals( "3")) {
          myList.remove(value);  // error
     }
}

根本原因，看下ArrayList源码：

public class ArrayList<e> extends AbstractList<e>
        implements Cloneable, Serializable, RandomAccess {


        @Override 
        public boolean remove(Object object) {
        Object[] a = array;
        int s = size;
        if (object != null) {
            for (int i = 0; i < s; i++) {
                if (object.equals(a[i])) {
                    System.arraycopy(a, i + 1, a, i, --s - i);
                    a[s] = null;  // Prevent memory leak
                    size = s;
                    modCount++;  // 只要删除成功都是累加
                    return true;
                }
            }
        } else {
            for (int i = 0; i < s; i++) {
                if (a[i] == null) {
                    System.arraycopy(a, i + 1, a, i, --s - i);
                    a[s] = null;  // Prevent memory leak
                    size = s;
                    modCount++;  // 只要删除成功都是累加
                    return true;
                }
            }
        }
        return false;
    }   


    @Override public Iterator<e> iterator() {
        return new 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();
            }
            if (rem == 0) {
                throw new NoSuchElementException();
            }
            remaining = rem - 1;
            return (E) ourList.array[removalIndex = ourList.size - rem];
        }   

          ......
     }
}

可以看出，ArrayList在调用Iterator时定义了一个局部变量，初始值为全局变量modCount，remove操作改变了modCount的值，因此抛出了异常。

• 解决方案
  既然根本原因是在使用迭代器遍历时进行了增删操作，那么解决办法就可以从两个角度出发，一是不适用迭代器遍历，二是使用安全的增删操作。
  代码如下：

// 1 使用Iterator提供的remove方法，用于删除当前元素
 for (Iterator<string> it = myList.iterator(); it.hasNext();) {
     String value = it.next();
      if (value.equals( "3")) {
          it.remove();  // ok
     }
}

// 2. 使用线程安全CopyOnWriteArrayList进行删除操作
List<string> myList = new CopyOnWriteArrayList<string>();
myList.add( "1");
myList.add( "2");
myList.add( "3");
myList.add( "4");
myList.add( "5");

Iterator<string> it = myList.iterator();

 while (it.hasNext()) {
     String value = it.next();
      if (value.equals( "3")) {
          myList.remove( "4");
          myList.add( "6");
          myList.add( "7");
     }
}


 // 3. 不使用Iterator进行遍历，需要注意的是自己保证索引正常
 for ( int i = 0; i < myList.size(); i++) {
     String value = myList.get(i);
     System. out.println( "List Value:" + value);
      if (value.equals( "3")) {
          myList.remove(value);  // ok
          i--; // 因为位置发生改变，所以必须修改i的位置
      }
  }

多线程

• 问题描述
  开启两个子线程，一个进行遍历，另外一个有条件删除元素：

final List<string> myList = createTestData();

//线程一：遍历
new Thread(new Runnable() {

     @Override
     public void run() {
          for (String string : myList) {
               System.out.println("遍历集合 value = " + string);

               try {
                    Thread.sleep(100);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
          }
     }
}).start();

//线程二：遍历删除 
new Thread(new Runnable() {

     @Override
     public void run() {

       for (Iterator<string> it = myList.iterator(); it.hasNext();) {
           String value = it.next();

           System.out.println("删除元素 value = " + value);

           if (value.equals( "3")) {
                it.remove();
           }

           try {
                    Thread.sleep(100);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
      }
     }
}).start();

如上，是使用单线程中第一种解决方案，使用迭代器自己的remove操作，然而在多线程中显然不行。依然会抛出异常。
接着来再看一下JavaDoc对java.util.ConcurrentModificationException异常的描述：

当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

说明以上办法在同一个线程执行的时候是没问题的，但是在异步情况下依然可能出现异常。

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

---

• 解决方案
  放弃使用迭代器遍历。