Regarding concurrent modification Exception [closed]

Answer 1

Your question seems (to me) to a little bit cryptic...

Regarding your first question, getting a ConcurrentModificationException in a single threaded environment, all you need to do would be something like so:

List<String> list =...;
for (String str : list)
{
    list.remove(str); //this should yield the exception
}

As to your second question, that code you have posted (the one with 2 threads) will most likely be prone to such an Exception. So far it is working due the amount of items you have and also the time out value. Should you change these, you will most likely experience this exception.

To avoid this, you could use synchronized blocks. By allowing each thread a synchronized section through which it can do it's collection modifications you should be able to steer clear from concurrent modification exceptions.

You could also regulate access to the list through the use of a Semaphore.

Answer 2

A ConcurrentModificationException can be thrown in a single thread environment. It is used whenever an object is modified in a context where it shouldn't, not necessarily in another thread.

Example:

public class CME {
    public static void main(String...args) {
        HashSet<Integer> coll = new HashSet<Integer>();
        coll.add(1);
        coll.add(2);
        coll.add(3);

        for(Integer i : coll) {
            coll.remove(i); // Throws ConcurrentModificationException
        }
    }
}

Answer 3

Yes it is possible to get this exception (not error) also in a single-threaded environment. More precisely the exception is thrown whenever a collection you're currently iterating through is modified either by another thread or by the current thread.

An example of a single-threaded scenario in which you get this error is the following:

Iterator<String> names = namesList.iterator();
while(names.hasNext()){
    String currentName = names.next();
    if(currentName.startsWith("A")){
           namesList.remove(currentName); //here you modify the original collection
    }
}

In this case, if the iterator is a fail-fast iterator (as most of the collection implementations provide) you will get a ConcurrentModificationException

Answer 4

ConcurrentModificationException will be thrown even in a single thread, if a collection is modified while iterating. e.g.

        List<String> lst = new ArrayList<String>();
        lst.add("sample");

        for(String str : lst) {
            lst.add("simple");
        }

Answer 5

Referring to the the Javadoc of ConcurrentModificationException,

Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will thow this exception.

Its not always that this exception would be thrown when a thread-safe collection is subject to concurrent access. Any structural modification (add/delete) will prompt this exception to occur.

In your particular example, you are modifying the collection outside of Iterator and hence it might throw this exception once the thread wakes up from sleep.

Answer 6

The classic example of a CME in a single thread is something like

List<String> strs = new ArrayList<String>();
strs.add("foo");
strs.add("bar");

for(String str : strs) {
  strs.add(str + " added");
}

The CME fires because you're in the process of iterating over the list and you modify it other than via the iterator. You are allowed to modify the list via its iterator without getting a CME:

ListIterator<String> strIt = strs.listIterator();
while(strIt.hasNext()) {
  String str = strIt.next();
  strIt.add(str + " added");
}
// strs now contains "foo", "foo added", "bar", "bar added"