Java Collection Quick Failure exception

Fast failure

in the JDK , there are many descriptions of quick failures in viewing collections:

Note that this implementation is not synchronous. If more than one thread accesses a hash map at the same time, and at least one of the threads modifies the mapping from the structure, it must remain externally synchronized. (Structural modification is any action that adds or deletes one or more mapping relationships; changing only the values associated with the key that the instance already contains are not structural modifications.) This is typically done by synchronizing the objects that naturally encapsulate the mapping. If such an object does not exist, you should use the Collections.synchronizedmap method to "wrap" the map. It is a good idea to do this at creation time to prevent unintended non-synchronous access to the mappings, as follows:

Map m =collections.synchronizedmap (new HashMap (...)); The iterator returned by all such "collection View Methods" is a quick failure: After the iterator has been created, if the mapping is modified from the structure, the iterator will throw unless modified by the Remove method of the iterator itself, any other time, in any way. Concurrentmodificationexception. Therefore, in the face of concurrent modifications, the iterator will soon fail completely without risking any uncertain behavior at any time in the future.

Note that the fast failure behavior of iterators is not guaranteed and, in general, there is no firm guarantee that there is an asynchronous concurrent modification. The fast-failing iterator does its best to throw concurrentmodificationexception. Therefore, it is wrong to write a program that relies on this exception, and the correct approach is that the fast failure behavior of the iterator should only be used to detect program errors.

fast failure: for non-concurrent collections, when they are iterated, for example iterator when iterating, iterator is another thread, if there are other threads (such as Collection ) for structural modification (modifying the contents of the collection), this iteration immediately senses and immediately throws concurrentmodificationexception The exception, not the iteration, tells you that something went wrong, causing a quick failure. If modified with iterator , this problem will not occur, such as Iterator.move (); in other words, it involves synchronization between multiple threads .

Example code:

[Java] view plain copy

1. Package Corejava;
3. import Java.util.HashMap;
4. import java.util.Hashtable;
5. import java.util.Iterator;
6. import Java.util.Map;
7. import java.util.Map.Entry;
8. import Java.util.concurrent.ConcurrentHashMap;

Public class Concurrenthashmaptest {

2. Public static void main (string[] args) {
4. 12.
6. hashtable<string, string> table = new hashtable<string, string> ();
8. Table.put ("A", "VB");
10. Table.put ("s", "er");
12. Table.put ("D", "FG");
14. Table.remove ("D");
16. iterator<entry<string, string>> Iterator = Table.entryset (). Iterator ();
18. 19.
20. while ( iterator.hasnext ()) {
22. System.out.println (Iterator.next (). GetValue ());
24. Iterator.remove ();//Use iterator directly to modify the program normal
26. *//Table.put ("C", "WC"); Delete data directly from Hashtable error
28. Table.remove ("D"), directly from the Hashtable add or delete data will be error hashtable,hashmap, such as non-concurrent sets if the iterative process of adding or subtracting data,
30. 25.}
32. 26.
34. System.out.println ("-----------");
36. 28.
38. hashmap<string, string> HashMap = new hashmap<string, string> ();
40. Hashmap.put ("A", "VB");
42. Hashmap.put ("s", "er");
44. Hashmap.put ("D", "FG");
46. iterator<entry<string, string>> iterators = Hashmap.entryset ()
48. Iterator ();
50. 35.
52. The. while (Iterators.hasnext ()) {
54. Panax Notoginseng System.out.println (Iterators.next (). GetValue ());
56. Iterators.remove ();//Normal
58. *//Hashmap.remove ("D");//directly from the Hashtable add and delete data will be error hashtable,hashmap and other non-concurrent sets, if the iterative process of adding or subtracting data, will quickly fail (a change detected, immediately throw an exception)
60. 40.}
62. 41.
64. System.out.println ("-----------");
66. 43.
68. concurrenthashmap<string, string> map = new concurrenthashmap<string, string> ();
70. Map.put ("A", "VB");
72. Map.put ("s", "er");
74. Map.put ("D", "FG");
76. iterator<entry<string, string>> mapiterator = Map.entryset (). Iterator ();
78. 49.
80. while ( mapiterator.hasnext ()) {
82. Wuyi System.out.println (Mapiterator.next (). GetValue ());
84. Map.Remove ("D");//Normal concurrent collection no quick failure problem
86. Map.put ("C", "WC");//Normal concurrent collection no quick failure problem
88. 54.}
90. System.out.println ("-----------");
92. . For (map.entry<string, string> entry:map.entrySet ()) {
94. System.out.println (Entry.getvalue () + "," + Entry.getkey ());
96. 58.}
98. System.out.println ("-----------");
100. For ( map.entry<string, string> entry:table.entrySet ()) {
102. System.out.println (Entry.getvalue () + "," + Entry.getkey ());
104. 62.}
106. 63.}
108. 64.
110. 65./*
112. * Final entry<k,v> NextEntry () {if (Modcount! = expectedmodcount) Throw
114. * New Concurrentmodificationexception (); Entry<k,v> e = next; if (E = =
116. * null) throw new Nosuchelementexception ();
118. 69. *
120. * if (next = e.next) = = null) {entry[] t = table; while (Index < t.length
122. * && (next = t[index++]) = = null); } current = e; return e; }
124. 72. */
126. 73.

74.}

Fast Failure Exception: This exception is thrown when the method detects concurrent modifications to an object, but does not allow this modification

Workaround:

A: Iterator removal

B: Lock the gun back. The collection is self-deleted. (Premise: A collection of thread synchronizations)

Java Collection Quick Failure exception