[Java] ConcurrentModificationException은 언제 발생할까? iterator의 동작 원리 살펴보기

💬 모던 자바를 공부하는 도중에, 책에서 나왔던 예제를 커스텀 하려다가 이런 상황을 만났다.

---

✔️ 문제 상황

먼저, 사용한 크루 클래스에 대한 정보이다.

public class Crew {
    private String name;
    private String nickname;
    private int age;
    private Course course;

    private Crew() {
        // 외부에서 인스턴스화 막기
    }

    public static Crew createByName(final String name, final int age, final Course course) {
        Crew crew = new Crew();
        crew.name = name;
        crew.age = age;
        crew.course = course;
        return crew;
    }

    public static Crew createByNickname(final String nickname, final int age, final Course course) {
        Crew crew = new Crew();
        crew.nickname = nickname;
        crew.age = age;
        crew.course = course;
        return crew;
    }

    public int getAge() {
        return age;
    }

    public Course getCourse() {
        return course;
    }

    public String getNickname() {
        return nickname;
    }
}

이후, 문제가 발생한 상황이다. 책에서는 다음과 같은 경우에 대해서 오류가 발생한다고 하였다.

List<Crew> crews = new ArrayList<>();
crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));
crews.add(Crew.createByNickname("hihi", 22, Course.BACKEND));

for (Crew crew : crews) {
    if (crew.getAge() == 20) {
        crews.remove(crew);
    }
}

 

이 경우에서는 당연하게도 ConcurrentModificationException이 발생한다.

---

 

✔️ ConcurrentModificationException이란?

먼저, ConcurrentModificationException이란, 자바에서 컬렉션 내부의 요소를 동시에 수정하려고 할 때 발생한다.

기본적으로 자바의 컬렉션 프레임워크는 Iterator를 사용하여 컬렉션의 요소를 반복하는데, 이때 컬렉션을 수정하면서 동시에 반복을 돌게 되면 해당 예외가 발생한다. 보통의 경우는 다중 스레드에서 동시에 수정할 때 많이 발생하지만, 단일 스레드에서도 위와 같이 컬렉션의 요소를 순회하는 동시에, 해당 컬렉션의 요소를 제거하게 되면 발생할 수 있다.

 

왜 이런 오류가 발생하는지는 아래에서 살펴보고, 다음의 예제를 생각해보자.

List<Crew> crews = new ArrayList<>();
crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));

for (Crew crew : crews) {
    if (crew.getAge() == 20) {
        crews.remove(crew);
    }
}

위 코드에서 crews.add()를 하는 작업을 한 줄 제거했을 뿐이기 때문에, 이 코드 역시 당연하게 예외가 발생할 것이다.

하지만, 놀랍게도 아무 오류도 발생하지 않는다... (???)

처음에 이걸 보고 대체 왜 오류가 발생하지 않는 것일까, 엄청 고민했었는데 이는 for-each의 동작 과정을 이해하면 된다.

 

---

✔️ Iterator 이해하기

우선, 첫 번째 케이스는 왜 오류가 발생하는 것일까? 해당 코드는 다음과 같이 Iterator를 사용하도록 변경된다.

List<Crew> crews = new ArrayList<>();
crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));
crews.add(Crew.createByNickname("hihi", 22, Course.BACKEND));

for (Iterator<Crew> iterator = crews.listIterator(); iterator.hasNext();) {
    Crew crew = iterator.next();
    if (crew.getAge() == 20) {
        crews.remove(crew);
    }
}

 

이때, iterator.next()를 진행하면서 다음 요소를 가져오게 되는데, next()는 내부적으로 다음과 같이 구현되어 있다.

public E next() {
    checkForComodification();
    int i = cursor;
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    return (E) elementData[lastRet = i];
}

 

여기서, 가장 상단의 checkForModification() 메서드를 호출하는 것을 볼 수 있다. 해당 메서드를 통해 어떠한 작업을 하고, (그것은 아래에서 설명할 예정이다!) 해당 요소의 인덱스에 대해서 cursor를 설정하게 된다. 그리고, 만약 인덱스가 사이즈보다 크면 다음 요소가 없음을 나타내며, elementData에서 해당 데이터를 가져와서 cursor는 그 다음 요소의 인덱스를, lastRet에는 현재 요소의 인덱스를 저장하게 된다.

 

 

💬 checkForComodification()

먼저, checkForComodification()에 대해서 살펴보자. 

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

modCount와 expectedModCount가 무엇일까?

modCount는 ModificationCount로, 해당 리스트에 대한 수정된 횟수를 관리한다. 해당 필드가 구현된 곳에 가서 주석을 살펴보면 다음과 같이 작성되어 있다.

 

The number of times this list has been structurally modified.
If the value of this field changes unexpectedly, the iterator (or list iterator) will throw a ConcurrentModificationException in response to the next, remove, previous, set or add operations.

구조적으로 수정된 횟수에 대해서 관리하며, 예기치 않게 변경이 되었을 경우 예외를 발생시킨다고 나와 있다. next(), remove(), previous() 등의 메서드를 호출할 때마다 modCount가 1씩 증가하게 된다.

 

반면에, expectedModCount는 ArrayList의 반복자(iterator)가 생성될 때의 modCount를 저장한다.

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

/**
 * An optimized version of AbstractList.Itr
 */
private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    // prevent creating a synthetic constructor
    Itr() {}
    ...
}

실제로 내부 구현을 보면, Itr라는 클래스에서 expectedModCount에 대해 modCount로 초기값을 지정해둔 것을 볼 수 있다.

 

즉, modCount는 반복자에 관련된 메서드를 호출할 때마다, expectedModCount는 가장 처음 생성할 때의 modCount를 저장한다는 것이다. 초기 상태를 저장해두고, 이를 비교하면서 관리하는 것이다. 초기 상태에서 달라졌기 때문에 현재 상태가 동일하지 않다는 의미로 concurrentModficiationException이 발생하게 되는 것이다.

 

그렇다면, 다시 우리의 구현체를 보자. 현재 우리는 if 조건문에 일치하는 요소에 대해서 제거 작업을 진행하고 있다.

현재 크루 리스트에는 나이가 20인 크루가 존재한다. 그리고, 해당 크루에 대해 제거하는 작업을 진행하게 된다.

    public boolean remove(Object o) {
        final Object[] es = elementData;
        final int size = this.size;
        int i = 0;
        found: {
            if (o == null) {
                for (; i < size; i++)
                    if (es[i] == null)
                        break found;
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))
                        break found;
            }
            return false;
        }
        fastRemove(es, i);
        return true;
    }

remove 메서드는 제거할 요소의 인덱스를 찾아낸 다음, 해당 인덱스에 있는 값을 제거한다. 이때, elementData는 ArrayList에서 관리하는 내부 배열이고 (리스트는 원래 배열로 관리된다) size는 현재 저장된 요소의 개수를 나타낸다. 만약 요소가 null이라면 ==로, null이 아니라면 equals로 비교하게 되는데, for문을 돌면서 제거할 요소를 찾아내면 해당 요소의 인덱스를 바탕으로 fastRemove() 메서드를 호출한다.

 

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i)
        System.arraycopy(es, i + 1, es, i, newSize - i);
    es[size = newSize] = null;
}

이때, fastRemove 메서드를 보면 익숙한 무언가가 보인다. 바로, modCount이다! 해당 리스트에 대해 수정이 가해졌기 때문에 modCount를 증가하게 되고, 해당 인덱스 이후의 모든 요소를 앞으로 한 칸씩 당기는 작업을 진행한다.

 

그럼, 여기서 현재 modCount는 1 증가한 형태일 것이다. 이 상태로 다음 iterator를 돌게 되면 어떻게 될까?

코드만 넣으면 지루할까봐 이미지... 근데 더 지루함

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

먼저, hasNext를 통해서 cursor와 사이즈가 일치하는지 체크해서 끝까지 도달했는지를 체크한다.

그리고, 다시 next()를 통해서 요소를 꺼내오게 될 것이다. 그리고, 또 다시 checkForComodification() 메서드를 확인하게 될 것이고, 이때 이미 변경된 modCount 변수로 인해서 expectedModCount와 달라지게 되어 오류가 발생하는 것이다! 🥲

실제로 디버깅 결과, 초기의 expectedModCount는 3이지만, modCount는 4가 되어서 예외가 발생함을 확인할 수 있다!

 

---

✔️ 엇... 그럼 요소가 2개일 때는 왜 오류가 발생하지 않았지?

이유는 단순하다. 'hi' 요소가 제거된 이후, 리스트와 iterator의 정보이다. 이미 리스트에서 요소가 제거되었기 때문에 내부적으로 관리되는 ArrayList의 사이즈가 1임을 볼 수 있다. (hello만 남아있음) 

 for (Iterator<Crew> iterator = crews.listIterator(); iterator.hasNext();) {
    Crew crew = iterator.next();
    if (crew.getAge() == 20) {
        crews.remove(crew);
    }
}

이때, iterator의 hasNext()를 통해 다음 요소가 존재하는지 체크하는데, 아까 봤던 것처럼 cursor와 size의 정보가 동일하지 않다면 다음 요소가 있다고 판단한다. 이때, 1 (커서 위치) = 1 (사이즈)로 두 개가 동일한 상황이 만들어지면서, next() 메서드를 통해 검증 메서드를 거치기도 전에 그냥 for문이 종료되어 예외가 발생하지도 않고 끝나는 것이었다.

 

---

✔️ 정리 - 그러면 어떻게 해결할 수 있지?

💡 그래서, 정확하게는 '조건에 해당하는 요소' 다음의 요소가 1개만 존재하고, 반복자를 초기화하지 않는다면 커서 위치와 사이즈가 동일한 상황이 발생할 수 있기 때문에, 오류가 발생하지 않고 종료될 수 있다! 라고 이해하면 된다.

 // 예외 발생 X
        List<Crew> crews = new ArrayList<>();
        crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));
        crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
        crews.add(Crew.createByNickname("hihi", 23, Course.BACKEND));

        for (Iterator<Crew> iterator = crews.listIterator(); iterator.hasNext(); ) {
            Crew crew = iterator.next();
            if (crew.getAge() == 20) {
                crews.remove(crew);
            }
        }

        // 예외 발생
        List<Crew> crews = new ArrayList<>();
        crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));
        crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
        crews.add(Crew.createByNickname("hihi", 23, Course.BACKEND));
        crews.add(Crew.createByNickname("wow", 23, Course.BACKEND));

        for (Iterator<Crew> iterator = crews.listIterator(); iterator.hasNext(); ) {
            Crew crew = iterator.next();
            if (crew.getAge() == 20) {
                crews.remove(crew);
            }
        }

단순히 요소의 개수만 상관있는 것이 아니라, 다음과 같이 조건에 일치하는 요소 다음의 요소가 2개 이상 존재할 때 예외가 발생한다.

 

그래서, 이 문제를 해결하기 위해서는 요소 자체를 삭제하는 것보다는 iterator를 remove() 해줘야 한다.

List<Crew> crews = new ArrayList<>();
crews.add(Crew.createByNickname("hi", 20, Course.BACKEND));
crews.add(Crew.createByNickname("hello", 21, Course.BACKEND));
crews.add(Crew.createByNickname("hihi", 23, Course.BACKEND));

for (Iterator<Crew> iterator = crews.listIterator(); iterator.hasNext();) {
    Crew crew = iterator.next();
    if (crew.getAge() == 20) {
        iterator.remove();
    }
}

 

그 이유는 내부 구현을 보면 바로 알 수 있다.

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

    try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount; // 핵심 로직!
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

lastRet는 next()에서 찾은 요소의 인덱스를 저장해두었는데, 해당 인덱스에 해당하는 요소를 제거하고, 커서를 해당 인덱스로 돌리는 것을 볼 수 있다. 그리고, 찾은 인덱스에 대해서 -1로 설정해서 제거 완료되었음을 표시해두고, expectedModCount와 modCount의 상태를 일치시켜 예외가 발생하지 않도록 만들어 준다! 👍

 

 

컬렉션 순회 시, 무심코 사용하지 않고 웬만하면 따로 복사본을 참조하여 제거하도록 하거나, 이런 식으로 iterator를 제거하는 식으로 코드를 작성하자 😎