[Java] Explains ConcurrentModificationException that occurs in java.util.ArrayList for newcomers

Introduction

• This is the 15th day of Stylez Advent Calendar 2016.
• At our company, we hold study sessions in the form of reading sessions for newcomers (for Java beginners rather than newcomers). Please refer to the following for details.
• I thought about a book for learning for java programmers (from newcomers to about 5 years)
• A story about starting a Java-related book club for newcomers
• [Java] Explains the mystery of JavaBeans serialization and field properties for newcomers with differences from POJO
• I am a lecturer for the above activities, but I often get questions that seem to be better to put out in the world, so I will write the answers to those questions in the article.
• This time, the ConcurrentModificationException received during the qualification course of [Java Programmer, Silver SE 8](http://www.oracle.com/jp/education/certification/jse8-2489021-ja.html) conducted in the same effort. About questions related to .

ConcurrentModificationException that also occurs in a single thread

• It is a well-known story that java.util.ConcurrentModificationException occurs when an unthread-safe java.util.ArrayList instance is changed from another thread, but it also occurs in single-threaded processing. ..
• I was asked that such a problem will be asked in various mock exams.
• So, about ConcurrentModificationException that occurs even in a single thread.
• As for the content, Exception is not thrown in the following cases.

DenaiConcurrentModificationException.java

public static void main(String[] args) {
	List<String> list = new ArrayList<String>();
	
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	
	for (String str : list) {
		if ("C".equals(str)) {
			list.remove(str);
		} else {
			System.out.println(str);
		}
	}
}

• In this case, ConcurrentModificationException is thrown.

DeruConcurrentModificationException.java

public static void main(String[] args) {
	List<String> list = new ArrayList<String>();
	
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	list.add("E");
	
	for (String str : list) {
		if ("C".equals(str)) {
			list.remove(str);
		} else {
			System.out.println(str);
		}
	}
}

When does a ConcurrentModificationException occur?

• As for how to ask questions, one of the above codes will be described, and what will happen to the result? It will be the contents such as.
• The point of view is whether ConcurrentModificationException is thrown or not. As a rough test preparation, if you remove the penultimate or last element of the list, it will be thrown "not done", otherwise it will be "doed".
• That's just the above, so let's take a look at the doc and code.

Java 8 SE ConcurrentModificationException documentation

• Class ConcurrentModificationException

This exception is thrown when a method that detects a parallel change in an object does not allow such a change.
For example, it is generally not allowed for one thread to iterate over a collection while another thread modifies the collection.
In such an environment, the results of iterative processing are usually not guaranteed.
Some iterators(Iterator)Implementation of(JREが提供するすべての一般的な目的のコレクションImplementation ofの、イテレータImplementation ofを含む)Is
You can choose to throw this exception if that behavior is detected.
The iterator that throws this exception is called a failfast iterator.
Iterators throw exceptions immediately and neatly to avoid the risk of unpredictable behavior at unpredictable points in the future.

• In short, if a change from another thread is detected during iterative processing, it will be thrown.
• Is the "Failfast Iterator" in the text a business management that says to fail early? It does not mean that it is an iterator that immediately raises an exception and interrupts processing if there is a possibility of unexpected changes.
• Exception for single thread is not mentioned here, so I will read it a little more.

This exception does not necessarily indicate that the object has not been updated in parallel by another thread.
If a single thread issues a set of methods that violate the object's conventions, the object throws this exception.
For example, if a thread modifies a collection directly while iterating over a collection with a failfast iterator.
The iterator throws this exception.

• First, java.util.ArrayList is a failfast iterator. It seems that a ConcurrentModificationException is always thrown when a thread modifies a collection directly while iterating with *.
• But it doesn't happen in some cases ... so let's take a look at the implementation.

Take a look at the implementation of java.util.ArrayList

• First, you can see that the extended for loop uses an iterator internally.

java

/**
 * An optimized version of AbstractList.Itr
 */
private class Itr implements Iterator<E> {}

With *, ConcurrentModificationException is thrown if there is a difference between expectedModCount and modCount every time the cursor moves. You can guess the role of the property from the name.

java

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

• If you read further, you can see that remove is incrementing modCount, which causes ConcurrentModificationException.

java

/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

• Focusing on System.arraycopy (elementData, index + 1, elementData, index, numMoved);, you can see that when the C element is deleted, the following element is moved up as shown below.

• As shown in the figure above, the element is moved up and the cursor does not change, so element 3 is processed after list.remove ("C "). Since 3 does not exist in the first stage, the processing ends as it is, the processing continues in the second stage, checkForComodification is executed, and ConcurrentModificationException is thrown.

Summary

• I wrote it hard with copy and paste, but you can understand it by looking at the implementation and debugging.
• During the qualification course, I actually debugged and derived the answer. ..