[Совет по Java #072]

Тема: ConcurrentHashMap при итерации не бросает ConcurrentModificationException — она weakly consistent.

Проблема: В отличие от обычных коллекций (HashMap, ArrayList), итераторы которых являются fail-fast и выбрасывают ConcurrentModificationException при обнаружении структурных изменений во время итерации, ConcurrentHashMap использует стратегию слабой согласованности (weakly consistent).

Это означает, что итератор не гарантирует, что отразит все изменения, произошедшие во время итерации, и не бросает исключения при конкурентных модификациях. Разработчики, привыкшие к fail-fast итераторам, ожидают, что при изменении карты во время обхода возникнет исключение, и могут строить логику, полагаясь на это поведение. Однако в ConcurrentHashMap это не происходит, и отсутствие исключения может замаскировать ошибки конкурентного доступа, приводя к тому, что итерация видит частично обновленные данные или пропускает новые элементы.

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

Решение: Осознайте, что итерация по ConcurrentHashMap безопасна в многопоточной среде, но не предоставляет моментального снимка (snapshot). Итератор отражает состояние карты на момент создания итератора, но может видеть изменения, произошедшие после (в зависимости от реализации). Для получения согласованного снимка используйте entrySet().toArray() или создайте копию карты перед итерацией. Если вам нужна строгая согласованность в момент обхода, синхронизируйтесь на самой карте или используйте Collections.synchronizedMap.

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

public class ConcurrentHashMapIteration {
    
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        
        //Итерация безопасна и не бросает ConcurrentModificationException
        Thread modifier = new Thread(() -> {
            map.put(4, "Four");   // модификация во время итерации
            map.remove(2);
        });
        
        // Итератор создается ДО изменений
        var iterator = map.entrySet().iterator();
        modifier.start();
        
        // Итерация продолжается, несмотря на изменения
        System.out.println("Итерация (weakly consistent):");
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey() + " -> " + entry.getValue());
            // Может увидеть 4, может не увидеть; 2 может быть или нет
            // Исключений не будет
        }
        modifier.join();
        
        // Для снимка: копирование
        Map<Integer, String> snapshot = new ConcurrentHashMap<>(map);
        System.out.println("Снимок: " + snapshot);
    }
}

Объяснение: ConcurrentHashMap использует внутреннюю сегментацию (bucket-level locking) и не блокирует всю структуру при модификации. Итераторы строятся на основе текущего состояния сегментов и не хранят отдельный снимок. Они не проверяют счетчик модификаций (в отличие от fail-fast итераторов), поэтому не бросают ConcurrentModificationException.

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


#Java #советы