Как можно избежать java.util.ConcurrentModificationException при использовании OSC?

О вашем коде

В вашем коде ваш цикл for-each выполняет итерацию по списку, а ваш osEvent изменяет список. Два потока, работающих одновременно, могут пытаться: перебирать список, в то время как другой добавляет к нему элементы. Ваш цикл for создает итератор.

Вы можете сделать следующее (при условии, что это единственные два места, где это происходит):

//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 );
        }   
    }
}

Или, как я объясню ниже, сделайте копию вектора, прежде чем перебирать его, это, вероятно, будет лучше.

Об исключении одновременного изменения

Это исключение не обязательно возникает в многопоточном коде. Это происходит, когда вы изменяете коллекцию во время ее итерации. Вы можете получить это исключение даже в однопоточных приложениях. Например, в цикле for-each, если вы удаляете или добавляете элементы в список, вы получаете ConcurrentModificationException.

Таким образом, добавление синхронизации в код не обязательно решит проблему. Некоторые альтернативы заключаются в создании копии данных, подлежащих итерации, или использовании итераторов, которые принимают модификации (например, ListIterator), или коллекции с итераторами моментальных снимков.

Очевидно, что в многопоточном фрагменте кода вам все равно придется позаботиться о синхронизации, чтобы избежать дальнейших проблем.

Позвольте мне привести несколько примеров:

Допустим, вы хотите удалить элементы из коллекции, перебирая ее. Ваши альтернативы, чтобы избежать ConcurrentModificationException:

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")));

Соберите все записи, которые вы хотите удалить, в расширенном цикле for, и после завершения итерации вы удалите все найденные записи.

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);

Или вы можете использовать ListIterator, который поддерживает метод удаления/добавления во время самой итерации.

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

В многопоточной среде вы можете рассмотреть возможность создания копии коллекции перед итерацией, что позволяет другим изменять исходную коллекцию, не влияя на итерацию:

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

В качестве альтернативы вы можете рассмотреть возможность использования других типов коллекций с помощью итераторов моментальных снимков, таких как java.util.ConcurrentCopyOnWriteArrayList, который гарантирует, что не будет выброшено ConcurrentModificationException. Но сначала прочитайте документацию, потому что этот тип коллекции подходит не для всех сценариев.

Если вам нужен эксклюзивный доступ, вам нужно заблокировать всю операцию в списке. Vector внутренне синхронизирован, но он по-прежнему снимает блокировку, а затем снова получает ее при каждом проходе итерации.

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();
    }
}

Это произойдет, если элементы будут добавлены/удалены из коллекции во время итерации. Некоторые вещи, на которые вы можете обратить внимание:

1. CopyOnWriteArrayList() - довольно дорого, но может помочь вам избежать исключения одновременной модификации, или
2. Использовать concurrentHashMap
3. Синхронизировать на самой итерации

Как уже упоминалось, исключение параллельной модификации возникает, когда вы выполняете итерацию по списку, и содержимое изменяется во время итерации. Для некоторых классов использование Iterator коллекции решит эту проблему, но не все коллекции реализуют Iterator.

Попробуйте использовать композицию, чтобы обернуть итерируемую коллекцию и перед итерацией получить блокировку, а затем после итерации снять блокировку. Чтобы это работало, любые операции добавления, удаления и т. д. должны быть защищены одной и той же блокировкой.

// 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();
  }
}

Затем использовать это сделать что-то вроде

 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();
     }
   }
 }