자바 면접 문제 총화 (3) 의 Array List 에서 modCount 역할

/**
     * The number of times this list has been structurally modified.
     * Structural modifications are those that change the size of the
     * list, or otherwise perturb it in such a fashion that iterations in
     * progress may yield incorrect results.
     *
     * 
This field is used by the iterator and list iterator implementation
     * returned by the {@code iterator} and {@code listIterator} methods.
     * If the value of this field changes unexpectedly, the iterator (or list
     * iterator) will throw a {@code ConcurrentModificationException} in
     * response to the {@code next}, {@code remove}, {@code previous},
     * {@code set} or {@code add} operations.  This provides
     * fail-fast behavior, rather than non-deterministic behavior in
     * the face of concurrent modification during iteration.
     *
     * 
Use of this field by subclasses is optional. If a subclass
     * wishes to provide fail-fast iterators (and list iterators), then it
     * merely has to increment this field in its {@code add(int, E)} and
     * {@code remove(int)} methods (and any other methods that it overrides
     * that result in structural modifications to the list).  A single call to
     * {@code add(int, E)} or {@code remove(int)} must add no more than
     * one to this field, or the iterators (and list iterators) will throw
     * bogus {@code ConcurrentModificationExceptions}.  If an implementation
     * does not wish to provide fail-fast iterators, this field may be
     * ignored.
     */
    protected transient int modCount = 0;

부모 클래스 AbstractList 에서 int 형의 속성 을 정의 합 니 다. modCount 는 Array List 의 구조 적 변화 횟수 를 기록 합 니 다.Array List 의 모든 구조 변화 와 관련 된 방법 에 modCount 의 값 을 추가 합 니 다. 이 는 add (), remove (), addAll (), removeRange () 와 clear () 방법 을 포함 합 니 다.이 방법 들 은 호출 될 때마다 modCount 의 값 을 1 로 추가 합 니 다.
주: add () 및 addAll () 방법의 modCount 값 은 그 중에서 호출 된 ensureCapacity () 방법 에서 추 가 됩 니 다.
AbstractList 의 iterator () 방법 (ArrayList 가 이 방법 을 직접 계승 하 였 습 니 다) 은 개인 내부 구성원 클래스 Itr 를 사용 하여 Itr 대상 (Iterator 인터페이스) 을 생 성하 여 되 돌려 줍 니 다.

public Iterator iterator() {
        return listIterator();
    }

Itr 는 Iterator () 인 터 페 이 스 를 실 현 했 습 니 다. 그 중에서 int 형의 속성 도 정 의 했 습 니 다. expected ModCount, 이 속성 은 Itr 류 가 초기 화 될 때 Array List 대상 의 modCount 속성 값 을 부여 합 니 다.

/**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

주: 내부 구성원 클래스 Itr 도 Array List 클래스 의 한 구성원 으로 모든 AbstractList 의 속성 과 방법 을 방문 할 수 있 습 니 다.이 점 을 이해 하면 Itr 류 의 실현 은 쉽게 이해 할 수 있다.
Itr. hasNext () 방법 중:

public boolean hasNext() {
            return cursor != size();
        }

AbstractList 의 size () 방법 을 호출 하여 현재 커서 위치 가 경 계 를 넘 었 는 지 비교 합 니 다.Itr. next () 방법 에서 Itr 도 AbstractList 에 정 의 된 get (int) 방법 을 호출 하여 현재 커서 에 있 는 요 소 를 되 돌려 줍 니 다.

        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();
            }
        }

 next () 방법 에서 checkForComodification () 방법 을 호출 하여 수 정 된 동기 화 검 사 를 진행 하 였 습 니 다.

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

이제 modCount 와 expected ModCount 의 역할 에 대해 잘 알 것 같 습 니 다.한 집합 대상 에 대해 낙대 작업 을 하 는 동시에 집합 대상 의 요 소 를 조작 하 는 것 을 제한 하지 않 는 다. 이런 조작 은 낙대 오 류 를 일 으 킬 수 있 는 add () 나 reove () 등 위험 조작 을 포함한다.AbstractList 에서 이러한 위험 을 피하 기 위해 간단 한 메커니즘 을 사용 했다.이것 이 바로 modCount 와 expected ModCount 의 역할 입 니 다.