Java.util.ConcurrentModificationException Anomaly Analysis

Java encountered a java.util.ConcurrentModificationException exception when manipulating container classes such as ArrayList, HashMap, TreeMap, and so on. Take ArrayList as an example, as in the following code snippet:

[Java]View Plaincopy

2. Import java.util.ArrayList;
4. Import Java.util.Iterator;
6. Import java.util.List;
8. Import java.util.concurrent.CopyOnWriteArrayList;
12. Public class Test {
16. public static void Main (string[] args) {
18. list<string> strlist = new arraylist<string> ();
20. Strlist.add ("string1");
22. Strlist.add ("string2");
24. Strlist.add ("string3");
26. Strlist.add ("String4");
28. Strlist.add ("String5");
30. Strlist.add ("String6");
34. //Operation mode 1:while (Iterator); Error
36. Iterator<string> it = Strlist.iterator ();
38. While (It.hasnext ()) {
40. String s = it.next ();
42. if ("string2". Equals (s)) {
44. Strlist.remove (s);
46. }
48. }
52. //Solution 1: Remove elements using Iterator's Remove method
54. //Operation mode 1:while (Iterator): no error
56. Iterator<string> it = Strlist.iterator ();
58. while (It.hasnext ()) {
60. String s = it.next ();
62. if ("string2". Equals (s)) {
64. It.remove ();
66. //          }
68. //      }
72. //Operation mode 2:foreach (Iterator); Error
74. for (String s:strlist) {
76. if ("string2". Equals (s)) {
78. Strlist.remove (s);
80. //          }
82. //      }
86. //Solution 2: Do not use iterator traversal, note the consistency of indexes
88. //Operation mode 3:for (non-iterator), no error; note Modify Index
90. for (int i=0; i<strlist.size (); i++) {
92. String s = strlist.get (i);
94. if ("string2". Equals (s)) {
96. Strlist.remove (s);
98. Strlist.remove (i);
100. i--;//element position changed, modify I
102. //          }
104. //      }
108. //Solution 3: Create a new temporary list, stage the elements you want to delete, and finally delete them together
110. list<string> templist = new arraylist<string> ();
112. for (String s:strlist) {
114. if (S.equals ("string2")) {
116. Templist.add (s);
118. //          }
120. //      }
122. View RemoveAll source, which uses iterator to traverse
124. Strlist.removeall (templist);
128. //Solution 4: Use thread-safe copyonwritearraylist for delete operations
130. list<string> strlist = new copyonwritearraylist<string> ();
132. Strlist.add ("string1");
134. Strlist.add ("string2");
136. Strlist.add ("String3");
138. Strlist.add ("String4");
140. Strlist.add ("String5");
142. Strlist.add ("String6");
144. Iterator<string> it = Strlist.iterator ();
146. while (It.hasnext ()) {
148. String s = it.next ();
150. if (S.equals ("string2")) {
152. Strlist.remove (s);
154. //          }
156. //      }
160. }
162. }

After executing the above code, the error is as follows:

[Plain]View Plaincopy

1. <span style= "FONT-SIZE:14PX;" >exception in thread "main" java.util.ConcurrentModificationException
2. At Java.util.arraylist$itr.checkforcomodification (Unknown Source)
3. At Java.util.arraylist$itr.next (Unknown Source)
4. At ConcurrentModificationException.Test.main (test.java:21)
5. </span>

In the 21st line error, i.e. It.next (), the iterator gets the next element in the wrong times. Find Java.util.ArrayList Line No. 830 and see the source code of It.next () as follows:

[Java]View Plaincopy

2. <span style="FONT-SIZE:14PX;" > @SuppressWarnings ("unchecked")
4. Public E Next () {
6. Checkforcomodification ();
8. int i = cursor;
10. if (i >= size)
12. throw new Nosuchelementexception ();
14. object[] Elementdata = ArrayList.  This.elementdata;
16. if (i >= elementdata.length)
18. throw new Concurrentmodificationexception ();
20. cursor = i + 1;
22. return (E) Elementdata[lastret = i];
24. }</span>

The Checkforcomodification () method is called and the code is as follows:

[Java]View Plaincopy

1. <span style= "FONT-SIZE:14PX;" >        final  Void checkforcomodification ()  {  
2.              if  (modcount !=  Expectedmodcount)   
3.                  throw new  concurrentmodificationexception ();   
4.          }</span>  

that is, compare modcount and Expectedmodcount two for equality. Modcount is a ArrayList inherited from Abstractlist, looking at the doc document of the Modcount attribute, the Modcount indicates the number of times the list has been structurally modified (structurally modified). Structurally modified is the action that causes the number of elements in the list to change, add,addall,remove in ArrayList, Fastremove,clear, RemoveRange,   Ensurecapacity,  ensurecapacityinternal,  ensureexplicitcapacity and other methods will make Modcount plus 1, and Batchremove, Removeall,retainall and other methods are based on the number of elements removed to increase the value of Modcount (RemoveAll and Retainall are called Batchremove implementation, the specific Modcount modification algorithm needs to be studied).

The operation mode 1 and Mode 2 in the first code fragment are in the way of iterators. When using the iterator method to get the iterator object (or using Listiterator to get the Listitr object), it is actually returning a iterator interface implementation class Arraylist$itr (inherited from abstractlist$ ITR), the class is an inner class of ArrayList, which has a expectedmodcount field that, when called Arraylist$itr's Next method, Checks whether the value of the modcount is equal to the value of expectedmodcount (in fact, it will be checked when calling next, remove, previous, set, add, etc.), Java.util.ConcurrentModificationException exceptions are thrown when they are not equal.

Why is this exception thrown? From the code can see the call 6 times the Add method, then the value of Modcount is 6, when using the iterator method to get the iterator object Modcount value is assigned to Expectedmodcount, At the beginning, expectedmodcount and modcount are equal when iterating to the second element (index=1) "string2", because the IF condition is true, and then the Remove method is called, The Modcount value is added 1 when the Remove method is called, at which point the value of Modcount is 7, and the value of Expectedmodcount is not changed when the arraylist$ is called again. The next method of ITR detects that Modecount and expectedmodcount are not equal and throws an exception.

What if the If statement is written as if (S.equals ("String5")) without throwing the exception? Arraylist$itr also has a field named cursor that points to the index of the element to be manipulated at iteration, with an initial value of 0, and a value of 1 for each call to the next method, noting that the element is first removed from the collection plus 1. When judging "string5", note is the second-to-last element, these cursor value is 5, remove the element "String5", the list of size 5, when the Hasnext method called Arraylist$itr to determine if there is no next element, The judgment is based on whether the value of the cursor is equal to the size, the difference is the next element, and when the two values are exactly equal, there is no next method to execute, and no exception is thrown, so the exception that is not thrown when the second-to-last element is deleted.

There are four solutions, just look at the first piece of code.

Java.util.ConcurrentModificationException Anomaly Analysis