Как реализована потокобезопасность в ConcurrentHashMap?

ConcurrentHashMap — это потокобезопасная реализация интерфейса Map, предназначенная для использования в многопоточных средах. Её ключевая особенность — высокая производительность при одновременном чтении и записи несколькими потоками, достигаемая за счёт умной организации блокировок.

Основной принцип: разделение блокировок

В отличие от Hashtable или Collections.synchronizedMap, которые используют одну общую блокировку на всю карту, ConcurrentHashMap делит свою внутреннюю структуру на части (ранее называвшиеся сегментами). Каждая часть может быть заблокирована независимо. Это означает, что если один поток пишет в один бакет, другой поток может читать или писать в другой бакет без ожидания.

Эволюция реализации

• До Java 8: Карта делилась на фиксированное количество сегментов (по умолчанию 16). Каждый сегмент был по сути отдельной хэш-таблицей со своей блокировкой (ReentrantLock).
• Java 8 и новее: Архитектура упрощена. Сегменты убраны, а данные хранятся в массиве узлов (Node[]). Блокировка теперь применяется на уровне отдельного бакета (первого узла в цепочке) только при необходимости (например, при вставке в непустой бакет). Для этого используются synchronized-блоки, что легче и эффективнее.

Ключевые механизмы потокобезопасности

• Операции чтения (get): Не требуют блокировок вообще. Они работают с volatile-полями (например, val, next в узлах), что гарантирует видимость последних записанных значений.
• Операции записи (put, remove): Используют блокировку только на конкретный бакет, где происходит изменение. Для инициализации или расширения таблицы может применяться отдельная блокировка или механизм CAS (Compare-And-Swap).
• Механизм CAS: Используется для атомарных операций, например, для увеличения счётчика размера (sizeCtl) или установки ссылки на новый узел при отсутствии конфликта. Это позволяет избегать блокировок в простых случаях.

Пример кода и применение

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

import java.util.concurrent.ConcurrentHashMap;

public class SimpleCache {
    private final ConcurrentHashMap cache = new ConcurrentHashMap<>();

    // Потокобезопасное получение или вычисление значения
    public Object getOrCompute(String key) {
        // get не блокирует другие потоки
        return cache.computeIfAbsent(key, k -> {
            // Дорогостоящее вычисление. Блокируется только бакет для этого ключа.
            return expensiveCalculation(k);
        });
    }

    private Object expensiveCalculation(String key) {
        // Имитация долгой операции
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        return "Result for " + key;
    }
}

Вывод: ConcurrentHashMap следует применять в высоконагруженных многопоточных приложениях, где требуется частое чтение и периодическая запись. Она обеспечивает отличный компромисс между потокобезопасностью и производительностью за счёт тонко-гранулярных блокировок и неблокирующего чтения. Не используйте её, если вам нужна строгая консистентность итераторов (например, как в synchronizedMap) или если операции записи очень редки — в таких случаях может хватить более простых решений.