How can java.util.ConcurrentModificationException be avoided when using OSC?

Question

The code I am working on is throwing the aforementioned exception. I am not very experienced with multi-threaded programming and I'm not having a lot of luck troubleshooting this.

The program is written in Java using Processing and OSC. The main OSC event handler is adding elements to a Vector. It is triggered on user input and therefore highly unpredictable. This Vector is also being iterated over and updated in Processing's animation thread which happens very regularly at about 60 times per second.

Occasionally, the OSC events handler is called as the Vector is being iterated over in the animation thread and the exception is thrown.

I have tried adding the "synchronized" modifier to the OSC event handler. I have also attempted to cue changes to the Vector until the next frame ( time step ) of the animation thread, but I'm finding that it just ends up delaying the exception being thrown.

What can I do to prevent this behavior? Is there a way to only access to the Vector if it isn't already in use?

Update: Two answers have suggested that the list is having elements added or removed as it is being iterated over. This is in fact what is happening due to the fact that OSC is triggering the handler from a thread other than the thread that is iterating over the list. I am looking for a way to prevent this.

Here is some pseudo-code:

Vector<String> list = new Vector<String>();
Vector<Particle> completedParticles = new Vector<Particle>();

public void oscEvent( OSCMessage message )
{
    list.add( new Particle( message.x, message.y ) );
}

public void draw()
{
    completedParticles.clear();
    for( Particle p : list )
    {
        p.draw();
        if( p.isComplete ) {
            completedParticles.add( p );
        }   
    }
    list.removeAll( completedParticles );
}

have you looked into CopyOnWriteArrayList or ConcurrentHashMap? either should help avoid ConcurrentModificationException — ali haider, Jul 03 '12 at 23:11
Your for loop is iterating over the list, and your osEvent modifies the list. Two threads, running simultaneously could be trying to iterate over the list while other is adding elements to it. Your for creates an iterator. — Edwin Dalorzo, Jul 03 '12 at 23:17
Yes, I see the problem. I am not certain how to avoid this though. — JeremyFromEarth, Jul 03 '12 at 23:18
synchronized(list) { /* your loop here */ } <-- This way you keep the lock and list.add(...) invoked by the other thread will block until the iteration completed — MartinK, Jul 03 '12 at 23:19
@jeremynealbrown Supposing these are the only two cases, you can sychronize access ver the list by making the methods `syncrhonized `, or by using `synchronized(list)`. — Edwin Dalorzo, Jul 03 '12 at 23:20
after three years, this questions and his answers just saved my life :) — Sr.Richie, Apr 26 '16 at 09:11

Edwin Dalorzo · Accepted Answer · 2012-07-03T23:46:24.537

About your Code

In your code, your for-each loop is iterating over the list, and your osEvent modifies the list. Two threads, running simultaneously could be trying to: iterate over the list while other is adding elements to it. Your for loop creates an iterator.

You can do the following (provided that these are the only two places where this occurs):

//osEvent
synchronized(this.list) {
   list.add( new Particle( message.x, message.y ) );
}

//draw
synchronized(this.list) {
  for( Particle p : list )
    {
        p.draw();
        if( p.isComplete ) {
            completedParticles.add( p );
        }   
    }
}

Or, as I explain below, make a copy of the vector before iterating over it, that will probably be better.

About Concurrent Modification Exception

This exception is not necessarily thrown in a multithreaded code. It happens when you modify a collection while it is being iterated. You can get this exception even in single-threaded applications. For instance, in a for-each loop, if you remove or add elements to a list, you end up getting a ConcurrentModificationException.

As such, adding synchronization to the code will not necessarily solve the problem. Some alternatives consist in making a copy of the data to be iterated, or using iterators that accept modifications (i.e. ListIterator), or a collection with snapshot iterators.

Evidently, in a multithreaded piece of code, you would still have to take care of synchronization to avoid further problems.

Let me give some examples:

Let's say you want to delete items from a collection while iterating over it. Your alternatives to avoid a ConcurrentModificationException are:

List<Book> books = new ArrayList<Book>();
books.add(new Book(new ISBN("0-201-63361-2")));
books.add(new Book(new ISBN("0-201-63361-3")));
books.add(new Book(new ISBN("0-201-63361-4")));

Collect all the records that you want to delete within an enhanced for loop, and after you finish iterating, you remove all found records.

ISBN isbn = new ISBN("0-201-63361-2");
List<Book> found = new ArrayList<Book>();
for(Book book : books){
    if(book.getIsbn().equals(isbn)){
        found.add(book);
    }
}
books.removeAll(found);

Or you may use a ListIterator which has support for a remove/add method during the iteration itself.

ListIterator<Book> iter = books.listIterator();
while(iter.hasNext()){
    if(iter.next().getIsbn().equals(isbn)){
        iter.remove();
    }
}

In a multithreaded environment, you might consider making a copy of the collection before iterating, as such, allowing others to modify the original collection without affecting iteration:

synchronized(this.books) {
   List<Book> copyOfBooks = new ArrayList<Book>(this.books)
}
for(Book book : copyOfBooks) {
   System.out.println(book);
}

Alternatively, you may consider using other types of collections using snapshot iterators, like java.util.ConcurrentCopyOnWriteArrayList which guarantees not to throw ConcurrentModificationException. But read the documentation first, because this type of collection is not suitable for all scenarios.

Thank you for your answer. I am in fact doing exactly what you recommend in your second code example where elements are being removed after iteration. It is possible that something is being added to the list while it is being iterated. However, as far as I can tell it would only be happening as a result of a concurrent procedure. — JeremyFromEarth, Jul 03 '12 at 23:06
@jeremynealbrown Then synchronization must be broken in your program somewhere. At some point, your collection is being modified while somewhere else is being iterated. Take into account that most collection iterators are backed by the original collection and that for-each loops use iterators behind the scenes. — Edwin Dalorzo, Jul 03 '12 at 23:12
Wrapping the iteration processes in synchronized blocks seems to have fixed it quite well. Not only did it fix the problem, I also learned some really useful tricks that I'm sure I'll use again. Thanks for all of you help.!! — JeremyFromEarth, Jul 03 '12 at 23:38

score 2 · Answer 2 · answered Jul 03 '12 at 23:22

If you want exclusive access, you need to lock around the entire operation on the list. Vector is internally synchronized, but it still releases the lock and then gets it again on each pass of the iteration.

java.util.concurrent.locks.Lock lock = new java.util.concurrent.locks.ReentrantLock();
Vector<String> list = new Vector<String>();
Vector<Particle> completedParticles = new Vector<Particle>();

public void oscEvent( OSCMessage message )
{
    lock.lock();
    try {
      list.add( new Particle( message.x, message.y ) );
    } finally {
      lock.unlock();
    }
}

public void draw()
{
    completedParticles.clear();
    lock.lock();
    try {
      for( Particle p : list )
      {
          p.draw();
          if( p.isComplete ) {
              completedParticles.add( p );
          }   
      }
      list.removeAll( completedParticles );
    } finally {
      lock.unlock();
    }
}

ali haider · Answer 3 · 2012-07-03T23:17:31.993

1

This will occur if items are added/removed from the collection during iteration. Some things you can look into:

CopyOnWriteArrayList() - quite costly but may help you avoid the concurrent modification exception, Or
Use concurrentHashMap
Synchronize on the iteration itself

edited Jul 03 '12 at 23:17

answered Jul 03 '12 at 23:06

ali haider

19,175
17
80
149

score 1 · Answer 4 · answered Jul 03 '12 at 23:26

As has already been mentioned, the concurrent modification exception happens when you are iterating over a list and contents change during iteration. For certain classes using the Iterator of the collection will solve this but not all collection implement Iterator.

Try using composition to wrap the collection being iterated over and before iterating obtain a lock, then after iterating release the lock. For this to work any add, remove etc., operations would need to be guarded by the same lock.

// example only
public class LockingVector {
  private final Vector v;
  private final ReentrantLock lock = new ReentrantLock();

  public void lock(){
    lock.lock();
  }
  public void unlock(){
    lock.unlock();
  }

  // other 'vector' method delegated to v
  public Object get() {
    return v.get();
  }
}

Then to use is do something like

 public class Main {
   public static void main(String[] args){
     Vector v = ...
     LockingVector lv = new LockingVector(v);
     try {
       lv.lock();
       // do stuff here (add, delete, iterate, etc.)
     } finally {
       lv.unlock();
     }
   }
 }

How can java.util.ConcurrentModificationException be avoided when using OSC?

4 Answers4

About your Code

About Concurrent Modification Exception