java中ConcurrentModificationException異常分析

阿新 • • 發佈：2019-01-16

jdk文件解釋：Iterator和ListIterator迭代器是快速失敗的，在迭代器建立之後，如果從結構上對列表進行修改，除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將丟擲 ConcurrentModificationException。因此，面對併發的修改，迭代器很快就會完全失敗，而不冒將來不確定的時間任意發生不確定行為的風險。下面通過分析LinkedList的原始碼來分析這種現象出現的原因，其他容易的類似：首先給出AbstractList的定義：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {}

在AbstractList類中定義了一個屬性：protected transient int modCount = 0,該屬性定義了列表結構上（增刪）被修改的次數。同時該類中定義瞭如下方法：

public Iterator<E> iterator() {
     return new Itr();
}

其中Itr類的定義如下：

   private class Itr implements Iterator<E> {
        /**
         * 此處只列出相關的屬性和方法
         */
        int expectedModCount = modCount;
        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if ( lastRet < 0)
                throw new IllegalStateException();
                checkForComodification();

            try {
                AbstractList.this.remove( lastRet);
                if ( lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

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

可以看出當獲取當前物件的迭代器時，迭代器會將此時的modCount儲存到expectedModCount，然後每次進行結構上的修改之前都會呼叫checkForComodification ()來檢查expectedModCount是否等於modCount，若相等則說明迭代器生成之後沒有通過呼叫原始連結串列的remove()等方法修改連結串列結構（若連結串列自己修改了結構如刪除掉一個節點，會導致迭代器遍歷過程中訪問該節點時發現節點為空導致異常，所以為防止該異常，會盡早去發現是否可能出現該問題，從而進行“快速失敗”丟擲ConcurrentModificationException），然後呼叫LinkedList中的remove（）方法來修改結構（下面會給出該方法，在該方法中會修改modCount++），結構修改之後迭代器需要修改expectedModCount以保證兩者始終相等。

LinkedList的類定義：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}
public abstract class AbstractSequentialList<E> extends AbstractList<E> {}

LinkedList中刪除一個節點的程式碼如下：

  /**
     * Unlinks non -null node x.
     */
    E unlink (Node<E> x) {
        // assert x != null;
        final E element = x. item;
        final Node<E> next = x. next;
        final Node<E> prev = x. prev;

        if (prev == null) {
            first = next;
        } else {
            prev. next = next;
            x. prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next. prev = prev;
            x. next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

正如jdk文件所說，ConcurrentModificationException異常的“快速失敗”機制是不能得到保證的，一般來說，存在不同步的併發修改時，不可能作出任何硬性保證。快速失敗迭代器盡最大努力丟擲ConcurrentModificationException。因此，編寫依賴於此異常的程式的方式是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程式錯誤。

java中ConcurrentModificationException異常分析

java中ConcurrentModificationException異常分析

java.util.ConcurrentModificationException異常分析

java編程中的異常分析及面向對象的思考總結[圖]

java中的異常處理

Java中的異常

Java中的異常和處理詳解

java中的異常（一）

Java中的異常處理機制

初探Java中的異常處理

java中的異常類型以及區別？？？？

JAVA中的異常處理及日誌(log4j為例)的使用

Java中的異常與錯誤處理

深入理解Java中的逃逸分析

java中的異常 try catch

java中捕獲異常

Java 中處理異常的 9 個最佳實踐

Java中的異常處理、泛型！圖文講解

JAVA中各種異常總結

java中排序原始碼分析（JDK1.8）

【轉】java中輸出異常資訊

java中ConcurrentModificationException異常分析

相關推薦