Краткий ответ

У ConcurrentHashMap вызов computeIfAbsent выполняется атомарно для конкретного ключа: функция вычисления применяется не более одного раза, если вычисление успешно возвращает ненулевое значение. Поэтому несколько потоков не создают и не публикуют независимые значения для одного отсутствующего ключа.

Это свойство относится именно к контракту ConcurrentHashMap, а не ко всем реализациям Map. Возврат null или выброс исключения не создаёт отображение, поэтому последующий вызов может повторить вычисление.

Исторический контекст

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

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

Постановка проблемы

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

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

Подробное решение

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

Минимальный пример:

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Config> cache = new ConcurrentHashMap<>();
Config config = cache.computeIfAbsent(
    "prod", key -> loadConfig(key)
);

Если loadConfig возвращает ненулевой объект, он сохраняется в карте. Если функция возвращает null, запись не создаётся; если она выбрасывает исключение, запись также не появляется, и следующий вызов может запустить вычисление снова.

Функция вычисления не должна изменять ту же карту, особенно тот же ключ: это может привести к IllegalStateException или к проблемному поведению из-за рекурсивной модификации. Также не следует выполнять внутри неё длительные блокирующие операции без оценки последствий: операции для того же ключа будут ждать завершения вычисления.

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

Ситуация из практики

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

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

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

Что кандидаты часто упускают

Гарантирует ли computeIfAbsent единственный вызов функции навсегда?

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

Можно ли безопасно считать функцию вычисления полностью изолированной от других потоков?

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

Чем отличается computeIfAbsent у ConcurrentHashMap от такого же метода у произвольной Map?

Наличие метода в интерфейсе Map само по себе не означает одинаковую потокобезопасность. Реализация по умолчанию может фактически состоять из проверки и последующей записи без атомарной гарантии между потоками. Для многопоточной ленивой инициализации нужно проверять контракт конкретной реализации; у ConcurrentHashMap такая операция специально определена как атомарная для ключа.