Обнаружение параллельных модификаций?

В зависимости от Вашей частоты обновления одним из моего избранного является CopyOnWriteArrayList или CopyOnWriteArraySet. Они создают новый список/набор на обновлениях для предотвращения параллельного исключения модификации.

Проверьте java.util.concurrent для версий стандартных классов Наборов, которые спроектированы для обработки параллелизма лучше.

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

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

Самый легкий способ протестировать это:

List<Blah> list = new ArrayList<Blah>();
for (Blah blah : list) {
     list.remove(blah); // will throw the exception
}

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

Да необходимо синхронизировать доступ к объектам наборов.

С другой стороны, можно использовать синхронизируемые обертки вокруг любого существующего объекта. См. Collections.synchronizedCollection (). Например:

List<String> safeList = Collections.synchronizedList( originalList );

Однако весь код должен использовать безопасную версию, и несмотря на это итерация, в то время как другой поток изменяет, приведет к проблемам.

Для решения итеративной проблемы скопируйте список сначала. Пример:

for ( String el : safeList.clone() )
{ ... }

Для более оптимизированных, ориентированных на многопотоковое исполнение наборов также посмотрите на java.util.concurrent.

Обертывание доступов к набору в синхронизируемом блоке является корректным способом сделать это. Стандартная практика программирования диктует какое-то использование блокировки механизма (семафор, взаимное исключение, и т.д.) при контакте с состоянием, которое совместно используется через несколько потоков.

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

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

Синхронизация, вероятно, предотвратила бы параллельные модификации, и это может быть тем, к чему Вы обращаетесь в конце, но это может закончить тем, что было дорогостоящим. Лучшая вещь сделать состоит в том, чтобы, вероятно, сесть и думать некоторое время о Вашем алгоритме. Если Вы не можете предложить свободное от блокировок решение, затем обратиться к синхронизации.

Посмотрите реализацию. Это в основном хранит интервал:

transient volatile int modCount;

и это увеличено, когда существует 'структурная модификация' (как, удаляют). Если итератор обнаруживает, что modCount изменился, он выдает Параллельное исключение модификации.

Синхронизация (через Collections.synchronizedXXX) не будет делать хорошее, так как это не гарантирует безопасности итератора, это только синхронизирует записи и чтения через помещенный, получите, установите...

См. java.util.concurennt и апачскую платформу наборов (это имеет некоторые классы, которые оптимизированы, действительно работают правильно в параллельной среде, когда существует больше чтений (которые не синхронизируются), чем записи - видят FastHashMap.

Collections.synchronizedList () представит список, номинально ориентированный на многопотоковое исполнение, и java.util.concurrent имеет более мощные функции.

Вы также можете синхронизировать по итерациям по списку.

List<String> safeList = Collections.synchronizedList( originalList );

public void doSomething() {
   synchronized(safeList){
     for(String s : safeList){
           System.out.println(s);

     }
   }

}

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

Это экономит часть памяти по методу .clone () и может быть быстрее в зависимости от того, что вы делаете в итерации ...

Это избавится от Вашего параллельного исключения модификации. Я не буду говорить с эффективностью однако ;)

List<Blah> list = fillMyList();
List<Blah> temp = new ArrayList<Blah>();
for (Blah blah : list) {
     //list.remove(blah);  would throw the exception
     temp.add(blah);
}
list.removeAll(temp);