Как вставить значение в HashMap без потерь при многопоточности

Проблема потокобезопасности HashMap

Классический HashMap в Java не является потокобезопасным. При одновременной вставке из нескольких потоков возможны три основные проблемы:

1. Потеря данных (вставленные значения могут пропасть)
2. Некорректный размер мапы (метод size() возвращает неверное значение)
3. Выход из строя (возможен бесконечный цикл или ConcurrentModificationException)

Рассмотрим решения по возрастанию сложности и производительности.

Решение 1: Synchronized методы (грубая блокировка)

Самый простой подход — обернуть операции в synchronized блоки или использовать Collections.synchronizedMap():

import java.util.*;

// Вариант 1: Использование synchronizedMap
Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

// При таком подходе ВСЕ методы мапы синхронизированы
map.put("ключ", 42); // Операция потокобезопасна

// Для итерации всё равно нужно синхронизировать
synchronized(map) {
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        // операции с entry
    }
}

Недостатки:

• Низкая производительность при высокой конкурентности
• Глобальная блокировка всей структуры на время каждой операции
• Не подходит для high-load систем

Решение 2: ConcurrentHashMap (оптимальный выбор)

ConcurrentHashMap из пакета java.util.concurrent — специализированная потокобезопасная реализация:

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

// Базовая вставка (потокобезопасная)
concurrentMap.put("ключ", 42);

// Атомарная вставка если ключ отсутствует
concurrentMap.putIfAbsent("ключ", 42);

// Сложные атомарные операции
concurrentMap.compute("ключ", (k, v) -> {
    return v == null ? 1 : v + 1; // атомарное инкрементирование
});

Ключевые особенности ConcurrentHashMap:

• Сегментированная блокировка (до Java 8) или CAS-операции (Java 8+)
• Разбивает мапу на сегменты, блокируя только один сегмент при записи
• Позволяет параллельное чтение даже при обновлении (читатели не блокируются)
• Высокая производительность при конкурентном доступе

// Пример атомарных операций
ConcurrentHashMap<String, AtomicInteger> map = new ConcurrentHashMap<>();

// Потокобезопасное увеличение счетчика
map.computeIfAbsent("counter", k -> new AtomicInteger(0)).incrementAndGet();

Решение 3: Атомарные операции с синхронизацией

Для сложных операций, где необходимо атомарно обновить несколько значений:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ThreadSafeMap<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void putIfBetter(K key, V value, Comparator<V> comparator) {
        lock.writeLock().lock();
        try {
            V existing = map.get(key);
            if (existing == null || comparator.compare(value, existing) > 0) {
                map.put(key, value);
            }
        } finally {
            lock.writeLock().unlock();
        }
    }
}

Решение 4: Потокобезопасные коллекции из Kotlin

В Kotlin Coroutines можно использовать:

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class ConcurrentMap<K, V> {
    private val map = mutableMapOf<K, V>()
    private val mutex = Mutex()
    
    suspend fun putSafe(key: K, value: V) = mutex.withLock {
        map[key] = value
    }
}

Сравнение подходов

Лучшие практики

1. Всегда предпочитайте ConcurrentHashMap для новых проектов
2. Используйте атомарные методы (compute(), merge(), putIfAbsent())
3. Избегайте итераций без синхронизации в многопоточной среде
4. Для счетчиков используйте ConcurrentHashMap с AtomicInteger

// Идеальный паттерн для счетчиков
ConcurrentHashMap<String, LongAdder> counters = new ConcurrentHashMap<>();

// Высокопроизводительный счетчик
counters.computeIfAbsent("requests", k -> new LongAdder()).increment();

В Android разработке учитывайте, что ConcurrentHashMap доступен с API 1, но некоторые атомарные методы — только с Java 8+ (требует minSdkVersion 24 или десмногеризацию через библиотеки совместимости).