Избегайте ненужного исключения ConcurrentModificationException при итерации

Крайне важно, чтобы пользователь вручную синхронизировал возвращенный список при повторении по нему:

List list = Collections.synchronizedList(new ArrayList());
...
synchronized (list) {
Iterator i = list.iterator(); // Должен находиться в синхронизированном блоке
while (i.hasNext())
foo(i.next());
}

Несоблюдение этого совета может привести к детерминированное поведение.

Твоих условий недостаточно

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

class ListEntry{
    Thing data;
    ListEntry next;
}

Когда вы перебираете things, вы выбираете одну запись из списка, а затем что-то делаете с данными. Если эта запись списка будет удалена во время итерации, итерация завершится преждевременно, если для параметра next установлено значение null, или она может сделать что-то совершенно другое, например выполнить итерацию по другому списку, если запись будет переработана.

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

Предложение решения

Добавьте два списка pendingremoval и pendingaddition, для которых ваш фоновый поток может добавлять запросы. Когда ваш поток обработки завершит один цикл обработки контейнера, замените списки pending* пустыми новыми и синхронно обработайте удаления в своем потоке обработки.

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

public class Processor {

    private List<Thing> pendingRemoval;
    private List<Thing> pendingAddition;
    private List<Thing> things;

    public void add(Thing aThing) {
        pendingAddition.add(aThing);
    }

    public void remove(Thing aThing) {
        pendingRemoval.add(aThing);
    }

    public void run() {
        while (true) {
            for (Thing thing : things) {
                if (!pendingRemoval.contains(thing)) {
                    thing.costlyOperation();
                }
            }

            synchronized (pendingRemoval) {
                things.removeAll(pendingRemoval);
                pendingRemoval.clear();
            }

            synchronized (pendingAddition) {
                things.addAll(pendingAddition);
                pendingAddition.clear();
            }
        }
    }
}

Редактировать: Забыли условие не обработки удаленных вещей

Edit2: В ответ на комментарии:

public class Processor {
    private Map<Thing, Integer> operations = new HashMap<Thing, Integer>();
    private List<Thing> things;

    public void add(Thing aThing) {
        synchronized (operations) {
            Integer multiplicity = operations.get(aThing);
            if (null == multiplicity) {
                multiplicity = 0;
            }
            operations.put(aThing, multiplicity + 1);
        }
    }

    public void remove(Thing aThing) {
        synchronized (operations) {
            Integer multiplicity = operations.get(aThing);
            if (null == multiplicity) {
                multiplicity = 0;
            }
            operations.put(aThing, multiplicity - 1);
        }
    }

    public void run() {
        while (true) {
            for (Thing thing : things) {
                Integer multiplicity;
                synchronized (operations) { 
                    multiplicity = operations.get(thing);
                }
                if (null == multiplicity || multiplicity > 0) {
                    thing.costlyOperation();
                }
            }

            synchronized (operations) {
                for (Map.Entry<Thing, Integer> operation : operations.entrySet()) {
                    int multiplicity = operation.getValue();
                    while(multiplicity<0){
                        things.remove(operation.getKey());
                    }
                    while(multiplicity>0){
                        things.add(operation.getKey());
                    }
                }
                operations.clear();
            }
        }
    }
}

private final Executor exec = ...;

private void methodThatAddsThings(final Thing t) {
    exec.execute(new Runnable() {
        public void run() {
          t.costlyOperation();
        }
    });
}

Кажется, это удовлетворяет A, B и C без необходимости делиться списком или синхронизировать что-либо. Теперь у вас также есть варианты масштабирования путем ограничения рабочей очереди или ограничения количества потоков обработки.

Если вам нужна возможность остановить ожидающую дорогостоящую операцию, поток, удаляющий Things, может использовать ExecutorService вместо Executor. Вызов submit() вернет Future, который вы можете сохранить на карте. При удалении Thing найдите его Future на карте и вызовите cancel() Future, чтобы предотвратить его запуск.