[Exception] ConcurrentModificationException(Java)

결론 : 동시 수정을 허용하지 않는 객체가 동시 수정을 감지하면 던지는 예외이다.

예를 들어, A 스레드가 X라는 Collection(list, set 등)을 반복하는 동안 B 스레드가 X를 수정(삽입, 삭제 등)하는 것은 일반적으로 허용되지 않는다.

흔한 예시로 for-each문에서 일반적인 수정은 허용하지 않는다.

public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();

        for (int i = 1; i < 11; i++) {
            set.add(i);
        }

        for (int s : set) {
            set.remove(s);
//            set.add(12);
        }

        System.out.println(set.size());
    }
}

/**
 * This exception may be thrown by methods that have detected concurrent
 * modification of an object when such modification is not permissible.
 * <p>
 * For example, it is not generally permissible for one thread to modify a Collection
 * while another thread is iterating over it.  In general, the results of the
 * iteration are undefined under these circumstances.  Some Iterator
 * implementations (including those of all the general purpose collection implementations
 * provided by the JRE) may choose to throw this exception if this behavior is
 * detected.  Iterators that do this are known as <i>fail-fast</i> iterators,
 * as they fail quickly and cleanly, rather that risking arbitrary,
 * non-deterministic behavior at an undetermined time in the future.
 * <p>
 * Note that this exception does not always indicate that an object has
 * been concurrently modified by a <i>different</i> thread.  If a single
 * thread issues a sequence of method invocations that violates the
 * contract of an object, the object may throw this exception.  For
 * example, if a thread modifies a collection directly while it is
 * iterating over the collection with a fail-fast iterator, the iterator
 * will throw this exception.
 *
 * <p>Note that fail-fast behavior cannot be guaranteed as it is, generally
 * speaking, impossible to make any hard guarantees in the presence of
 * unsynchronized concurrent modification.  Fail-fast operations
 * throw {@code ConcurrentModificationException} on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness: <i>{@code ConcurrentModificationException}
 * should be used only to detect bugs.</i>
 *
 * @author  Josh Bloch
 * @see     Collection
 * @see     Iterator
 * @see     Spliterator
 * @see     ListIterator
 * @see     Vector
 * @see     LinkedList
 * @see     HashSet
 * @see     Hashtable
 * @see     TreeMap
 * @see     AbstractList
 * @since   1.2
 */

이 예외를 던졌다면, 단단히 잘못된 코드를 작성했다고 호되게 혼내는 주석도 볼 수 있다. (喝!)