有關java.util.ConcurrentModificationException
阿新 • • 發佈：2017-06-29
bug 底層 hat exc iss contex violate acc object
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 fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.
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 ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.
產生這個異常的原因：並發改動對象，而對象不支持並發改動。
有關java.util.ConcurrentModificationException
java doc對這個類的定義：
This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.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 fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.
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 ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.
產生這個異常的原因：並發改動對象，而對象不支持並發改動。
比較常見的是多線程並發，或者單線程遍歷集合的時候同一時候改動集合元素。
比方：package com.doctor.java8;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* This program crashes by throwing java.util.ConcurrentModificationException. Why? Because the
* iterators of ArrayList are fail-fast; it fails by throwing ConcurrentModificationException if it detects that
* the underlying container has changed when it is iterating over the elements in the container. This behavior
* is useful in concurrent contexts when one thread modifies the underlying container when another thread is
* iterating over the elements of the container.
*
* @author sdcuike
*
* Created on 2016年3月6日 上午10:24:21
*/
public class ModifyingList {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
list.add("three");
}
// one
// Exception in thread "main" java.util.ConcurrentModificationException
// at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
// at java.util.ArrayList$Itr.next(ArrayList.java:851)
// at com.doctor.java8.ModifyingList.main(ModifyingList.java:24)
}
}
CopyOnWriteArrayList
既然普通集合的iterators是fail-fast的即不支持訪問同一時候改動的場景。那我們用並發容器CopyOnWriteArrayList。package com.doctor.java8;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* Modifying CopyOnWriteArrayList
*
* Observe that the element “four” added three times is not printed as part of the output. This is because
* the iterator still has access to the original (unmodified) container that had three elements. If you create a
* new iterator and access the elements, you will find that new elements have been added to aList.
*
* @author sdcuike
*
* Created on 2016年3月6日 上午10:32:39
*/
public class ModifyingCopyOnWriteArrayList {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
list.add("one");
list.add("two");
list.add("three");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
list.add("four");
}
// one
// two
// three
System.out.println("============");
iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// one
// two
// three
// four
// four
// four
}
}
java.util.concurrent.CopyOnWriteArrayList<E>
A thread-safe variant of java.util.ArrayList in which all mutative operations (add,set, and so on) are implemented by making a fresh copy of
the underlying array.
當對CopyOnWriteArrayList調用改動數據操作方法的時候。會copy一份新的內部數組結構，而對原來的內部數組結構沒影響。
假設要訪問新的數據，我們必須又一次獲取底層新的數組結構的iterator（見上面的程序）。
有關java.util.ConcurrentModificationException