In this article, we will study a predefined Exception in Java which is ConcurrentModificationException. It is a very common exception that occurs while working with Collections in Java. You must know this exception and how to handle the same.<\/p>\n
We will study this Exception with examples and the ways to avoid this exception.<\/p>\n
Whenever we try to modify an object concurrently without permission, then the ConcurrentModificationException occurs. We often face this exception usually when we are working with Collection classes of Java. This exception is present in the java.util package.<\/p>\n
The Collection classes of Java are very fail-fast and if we try to change them while some thread is traversing over it using an iterator, then we will get a ConcurrentModificationException from iterator.next() method.<\/p>\n
The Concurrent modification exception can occur in the multithreaded as well as a single-threaded Java programming environment.<\/p>\n
Let\u2019s take an example. A thread is not permitted to modify a Collection when some other thread is iterating over it because the result of the iteration becomes undefined with it.<\/p>\n
Some implementations of the Iterator class throw this exception, including all those general-purpose implementations of Iterator that JRE provides.<\/p>\n
Such Iterators that do this are called fail-fast because they throw the exception as soon as they encounter such a situation rather than facing undetermined behavior of the Collection any time in the future.<\/p>\n
Note:<\/strong><\/em> Now, let us discuss the Java concurrent modification exception with the help of an example.<\/p>\n Code 1 to explain ConcurrentModificationException:<\/strong><\/p>\n Output<\/strong><\/p>\n The above output message says that the exception occurs when we call the next method as the iterator is iterating the list and we are making modifications in it simultaneously.<\/p>\n But if we make changes in the hashmap like the code below, then it will not throw any such exception as the size of the hashmap won’t change. So let\u2019s see this example.<\/p>\n Code to remove the exception from the above program:<\/strong><\/p>\n Output<\/strong><\/p>\n Code 2 to explain ConcurrentModificationException:<\/strong><\/p>\n Output<\/strong><\/p>\n From the output message, it is clear that the concurrent modification exception occurs when we try to call the iterator next() method.<\/p>\n You must be thinking how the Iterator checks for the modification, this is because the implementation of Iterator is present in AbstractList class where an int variable, modCount is present with the definition.<\/p>\n The modCount variable provides the number of times list size is changed. Every next() call used the modCount variable to check for any modifications in a function checkForComodification().<\/p>\n There are 4 types of constructors of ConcurrentModificationException which are given in the following table:<\/p>\n We can follow some precautions or ways to avoid ConcurrentModificationException in a multi-threaded environment:<\/p>\n 1.<\/strong> We can iterate over the array instead of iterating over the collection class. Following this way, we can work very well with small-sized lists, but this will degrade the performance if the array size is very large.<\/p>\n 2.<\/strong> Locking the list by putting it in the synchronized block is another way to avoid the concurrent modification exception. This is not an effective approach; it is not using the sole purpose of multi-threading.<\/p>\n 3.<\/strong> The classes ConcurrentHashMap and CopyOnWriteArrayList of JDK 1.5 or higher versions can also help us in avoiding concurrent modification exceptions.<\/p>\n We can also avoid the Concurrent Modification Exception in a single threaded environment. We can use the remove() method of Iterator to remove the object from the underlying collection object. But in this case, you can remove only the same object and not any other object from the list.<\/p>\n Code to understand above concept:<\/strong><\/p>\n Output<\/strong><\/p>\n We can also use the for loop rather than an iterator to avoid concurrent modification exceptions in a single-threaded environment. We can ensure that our code takes care of the extra added objects in the list.<\/p>\n Code to use for loop to remove Concurrent Modification Exception:<\/strong><\/p>\n Output<\/strong><\/p>\n The ConcurrentModificationException will occur if you try to modify the structure of the original list with the subList. Let\u2019s see this with a simple example.<\/p>\n Example:<\/strong><\/p>\n Output<\/strong><\/p>\n This was all about ConcurrentModificationException in Java. We discussed the cause for occurring this exception and discussed different ways to deal with this exception.<\/p>\n","protected":false},"excerpt":{"rendered":" In this article, we will study a predefined Exception in Java which is ConcurrentModificationException. It is a very common exception that occurs while working with Collections in Java. You must know this exception and...<\/p>\n","protected":false},"author":1,"featured_media":79178,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[183],"tags":[2922,2923,2924,2925],"class_list":["post-79156","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-concurrentmodificationexception","tag-concurrentmodificationexception-java","tag-java-concurrentmodificationexception","tag-java-util-concurrent-modification-exception"],"yoast_head":"\n
\nIt is not necessary that this exception will occur only when some other thread tries to modify a Collection object. It can also occur if the methods of a single thread are trying to violate the contract of the object.<\/p>\nExample of Java ConcurrentModificationException<\/h3>\n
package com.techvidvan.concurrentmodificationexception;\nimport java.awt.List;\nimport java.util. * ;\npublic class ConcurrentModificationException {\n public static void main(String[] args) {\n ArrayList < Integer > list = new ArrayList < >();\n\n list.add(1);\n list.add(2);\n list.add(3);\n list.add(4);\n list.add(5);\n\n Iterator < Integer > iterator = list.iterator();\n while (iterator.hasNext()) {\n Integer value = iterator.next();\n System.out.println(\"The value of the List is:\" + value);\n if (value.equals(3)) list.remove(value);\n }\n }\n}<\/pre>\n
\nThe value of the List is:2
\nThe value of the List is:3
\nException in thread “main” java.util.ConcurrentModificationException
\nat java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
\nat java.util.ArrayList$Itr.next(ArrayList.java:851)
\nat ConcurrentModificationException.main(ConcurrentModificationException.java:18)<\/div>\npackage com.techvidvan.concurrentmodificationexception;\nimport java.awt.List;\nimport java.util. * ;\npublic class concurrentModificationException {\n public static void main(String[] args) {\n HashMap < Integer,\n Integer > map = new HashMap < >();\n map.put(1, 1);\n map.put(2, 2);\n map.put(3, 3);\n\n Iterator < Integer > it = map.keySet().iterator();\n while (it.hasNext()) {\n Integer key = it.next();\n System.out.println(\"The Map Value is: \" + map.get(key));\n if (key.equals(2)) {\n map.put(1, 4);\n }\n }\n }\n}<\/pre>\n
\nThe Map Value is: 2
\nThe Map Value is: 3<\/div>\npackage com.techvidvan.concurrentmodificationexception;\nimport java.util.ArrayList;\nimport java.util.HashMap;\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util.Map;\n\npublic class ConcurrentModificationExceptionExample {\n public static void main(String args[]) {\n List < String > myList = new ArrayList < String > ();\n\n myList.add(\"1\");\n myList.add(\"2\");\n myList.add(\"3\");\n myList.add(\"4\");\n myList.add(\"5\");\n\n Iterator < String > it = myList.iterator();\n while (it.hasNext()) {\n String value = it.next();\n System.out.println(\"List Value:\" + value);\n if (value.equals(\"3\")) myList.remove(value);\n }\n\n Map < String,\n String > myMap = new HashMap < String,\n String > ();\n myMap.put(\"1\", \"1\");\n myMap.put(\"2\", \"2\");\n myMap.put(\"3\", \"3\");\n\n Iterator < String > it1 = myMap.keySet().iterator();\n while (it1.hasNext()) {\n String key = it1.next();\n System.out.println(\"Map Value:\" + myMap.get(key));\n if (key.equals(\"2\")) {\n myMap.put(\"1\", \"4\");\n \/\/ myMap.put(\"4\", \"4\");\n }\n }\n }\n}<\/pre>\n
\nList Value:2
\nList Value:3
\nException in thread “main” java.util.ConcurrentModificationException
\nat java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
\nat java.util.ArrayList$Itr.next(ArrayList.java:851)
\nat
\ncom.techvidvan.ConcurrentModificationException.ConcurrentModificationExceptionExample.main(ConcurrentModificationExceptionExample.java:22)<\/div>\nConstructors of ConcurrentModificationException<\/h3>\n
\n\n
\n S.N<\/b><\/td>\n Constructor<\/b><\/td>\n Description<\/b><\/td>\n<\/tr>\n \n 1.<\/span><\/td>\n public ConcurrentModificationException()<\/span><\/td>\n This constructor creates a ConcurrentModification Exception with no parameters.<\/span><\/td>\n<\/tr>\n \n 2.<\/span><\/td>\n public ConcurrentModificationException(String message)<\/span><\/td>\n This constructor creates a ConcurrentModification Exception with a detailed message of the Exception.<\/span><\/td>\n<\/tr>\n \n 3.\u00a0<\/span><\/td>\n public ConcurrentModificationException(Throwable cause)<\/span><\/td>\n This constructor creates a ConcurrentModification Exception with a cause of the exception and a message which is (cause==null?null:cause.toString()). We can later retrieve this\u00a0 message by using Throwable.getCause().<\/span><\/td>\n<\/tr>\n \n 4.<\/span><\/td>\n public ConcurrentModificationException(String message, Throwable cause)<\/span><\/td>\n This\u00a0 constructor creates a ConcurrentModification Exception with a cause and detailed message. We can retrieve this\u00a0 message using Throwable.getMessage() and the cause by Throwable.getCause().<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n How to avoid ConcurrentModificationException in a multi-threaded environment?<\/h3>\n
How To Avoid Concurrent Modification Exception in a single-threaded environment?<\/h3>\n
package com.technvidvan.concurrentmodificationexception;\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.concurrent.ConcurrentHashMap;\nimport java.util.concurrent.CopyOnWriteArrayList;\n\npublic class AvoidConcurrentModificationException {\n public static void main(String[] args) {\n List < String > myList = new CopyOnWriteArrayList < String > ();\n\n myList.add(\"1\");\n myList.add(\"2\");\n myList.add(\"3\");\n myList.add(\"4\");\n myList.add(\"5\");\n\n Iterator < String > it = myList.iterator();\n while (it.hasNext()) {\n String value = it.next();\n System.out.println(\"List Value:\" + value);\n if (value.equals(\"3\")) {\n myList.remove(\"4\");\n myList.add(\"6\");\n myList.add(\"7\");\n }\n }\n System.out.println(\"List Size:\" + myList.size());\n\n Map < String,\n String > myMap = new ConcurrentHashMap < String,\n String > ();\n myMap.put(\"1\", \"1\");\n myMap.put(\"2\", \"2\");\n myMap.put(\"3\", \"3\");\n\n Iterator < String > it1 = myMap.keySet().iterator();\n while (it1.hasNext()) {\n String key = it1.next();\n System.out.println(\"Map Value:\" + myMap.get(key));\n if (key.equals(\"1\")) {\n myMap.remove(\"3\");\n myMap.put(\"4\", \"4\");\n myMap.put(\"5\", \"5\");\n }\n }\n System.out.println(\"Map Size:\" + myMap.size());\n }\n}<\/pre>\n
\nList Value:2
\nList Value:3
\nList Value:4
\nList Value:5
\nList Size:6
\nMap Value:1
\nMap Value:2
\nMap Value:4
\nMap Value:5
\nMap Size:4<\/div>\nUsing of loop to avoid ConcurrentModificationException<\/h3>\n
package com.technvidvan.concurrentmodificationexception;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.concurrent.ConcurrentHashMap;\nimport java.util.concurrent.CopyOnWriteArrayList;\npublic class AvoidConcurrentModificationException {\n public static void main(String[] args) {\n List < String > myList = new CopyOnWriteArrayList < String > ();\n\n myList.add(\"1\");\n myList.add(\"2\");\n myList.add(\"3\");\n myList.add(\"4\");\n myList.add(\"5\");\n\n for (int i = 0; i < myList.size(); i++) {\n System.out.println(\"List value: \" + myList.get(i));\n if (myList.get(i).equals(\"3\")) {\n myList.remove(i);\n i--;\n myList.add(\"6\");\n }\n }\n System.out.println(\"List Size:\" + myList.size());\n }\n}<\/pre>\n
\nList value: 2
\nList value: 3
\nList value: 4
\nList value: 5
\nList value: 6
\nList Size:5<\/div>\npackage com.technvidvan.concurrentmodificationexception;\nimport java.util.ArrayList;\nimport java.util.List;\npublic class ConcurrentModificationExceptionWithArrayListSubList {\n public static void main(String[] args) {\n\n List < String > names = new ArrayList < >();\n names.add(\"Java\");\n names.add(\"PHP\");\n names.add(\"SQL\");\n names.add(\"Angular 2\");\n\n List < String > first2Names = names.subList(0, 2);\n\n System.out.println(names + \" , \" + first2Names);\n\n names.set(1, \"JavaScript\");\n \/\/ check the output below. :)\n System.out.println(names + \" , \" + first2Names);\n\n \/\/ Let's modify the list size and get ConcurrentModificationException\n names.add(\"NodeJS\");\n System.out.println(names + \" , \" + first2Names); \/\/ this line throws exception\n\n }\n}<\/pre>\n
\n[Java, JavaScript, SQL, Angular 2] , [Java, JavaScript]
\nException in thread “main” java.util.ConcurrentModificationException
\nat java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231)
\nat java.util.ArrayList$SubList.listIterator(ArrayList.java:1091)
\nat java.util.AbstractList.listIterator(AbstractList.java:299)
\nat java.util.ArrayList$SubList.iterator(ArrayList.java:1087)
\nat java.util.AbstractCollection.toString(AbstractCollection.java:454)
\nat java.lang.String.valueOf(String.java:2994)
\nat java.lang.StringBuilder.append(StringBuilder.java:131)
\nat com.techvidvan.concurrentmodificationexception.ConcurrentModificationExceptionWithArrayListSubList.main(ConcurrentModificationExceptionWithArrayListSubList.java:23)<\/div>\nConclusion<\/h3>\n