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

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

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

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

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

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

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

чтобы решить проблему итерации, сначала скопируйте список. Пример:

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

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

обычно вы получаете ConcurrentModificationException если вы пытаетесь удалить элемент из списка во время его итерации.

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

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

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

вы можете попробовать использовать защитное копирование, чтобы изменения в one List не влияют на другие.

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

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

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

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

посмотреть реализацию. Он в основном хранит int:

transient volatile int modCount;

и это увеличивается, когда есть "структурная Модификация" (например, удалить). Если итератор обнаруживает, что modCount изменен, он создает исключение параллельной модификации.

синхронизация (через коллекции.synchronizedXXX) не будет делать ничего хорошего, поскольку он не гарантирует безопасность итератора, он синхронизирует только записи и чтения через put, get, set ...

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

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

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

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

     }
   }

}

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

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

сборники.synchronizedList() отобразит список номинально потокобезопасный и java.утиль.одновременно имеет более мощные характеристики.

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

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