Какие знаешь потокобезопасные коллекции?

Потокобезопасные коллекции в Java/Android

В контексте разработки Android, работа с многопоточностью — критически важная тема, поскольку современные приложения часто выполняют множество задач параллельно (обработка сетевых запросов, работа с файлами, обновление UI). Использование стандартных коллекций (ArrayList, HashMap) в многопоточных сценариях без синхронизации приводит к состояниям гонки (race conditions), повреждению данных и недетерминированному поведению. Для безопасной работы в таких условиях применяются специальные потокобезопасные коллекции.

Классификация потокобезопасных коллекций

1. Коллекции из java.util.concurrent (JUC)

Это основной набор, предоставляемый Java и доступный в Android (с учетом версии API).

• ConcurrentHashMap — наиболее часто используемая потокобезопасная реализация Map. Не блокирует всю таблицу при операциях, использует блочную синхронизацию (segment locking в старых версиях или CAS-операции в новых). Позволяет одновременные чтения и ограниченное количество параллельных записей.

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
Integer value = map.get("key");

• CopyOnWriteArrayList и CopyOnWriteArraySet — коллекции, использующие стратегию "copy-on-write". При каждой модификации (add, set, remove) создается новый внутренний массив. Это обеспечивает безопасность для чтения (итерации) в многопоточном контексте, но дорого для частых модификаций. Идеальны для часто читаемых, но редко изменяемых списков (например, списков наблюдателей).

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("item");
for (String s : list) { // Итерация безопасна даже при параллельных изменениях
    System.out.println(s);
}

• ConcurrentLinkedQueue / ConcurrentLinkedDeque — неблокирующие очереди на основе CAS (Compare-And-Swap). Позволяют высокопроизводительные операции добавления и удаления из головы/хвоста множеством потоков.

• Блокирующие очереди (BlockingQueue интерфейс и его реализации):

    * **`ArrayBlockingQueue`** — очередь фиксированного размера на массиве.
    * **`LinkedBlockingQueue`** — очередь на связном списке, может иметь ограничение или быть неограниченной.
    * **`SynchronousQueue`** — очередь для прямого hand-off между потоками (продавец ждет покупателя).
    Эти коллекции критически важны для реализации паттерна **Producer-Consumer**.

2. Синхронизированные версии через Collections.synchronizedXxx()

Устаревший, но все еще встречающийся подход. Методы Collections.synchronizedList(), synchronizedMap(), synchronizedSet() возвращают коллекции, где каждая операция защищена мьютексом на самом объекте коллекции. Это обеспечивает безопасность, но приводит к низкой производительности при высоком уровне конкуренции, так как блокируется вся коллекция.

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// Доступ к syncList безопасен, но итерация требует явной синхронизации
synchronized(syncList) {
    for (String item : syncList) {
        // ...
    }
}

3. Специализированные коллекции для Android и Kotlin

• Коллекции из kotlinx.coroutines — в мире Kotlin Coroutines для безопасного обмена состояниями между корутинами используются не коллекции из JUC, а специальные конструкции типа Channel (аналог BlockingQueue, но неблокирующий для корутин) и MutableSharedFlow (для событий).
• LiveData (из Android Architecture Components) — хотя это не коллекция, это потокобезопасный holder данных, который уведомляет наблюдателей об изменениях и автоматически обновляет UI в главном потоке. Внутренняя реализация использует механизмы синхронизации.
• Работа с Collections в сочетании с Synchronized аннотацией в Kotlin — Kotlin предоставляет аннотацию @Synchronized для методов и возможность использовать корутины с мьютексами (Mutex) для более гибкой синхронизации.

Ключевые принципы выбора

1. ConcurrentHashMap vs synchronizedMap — почти всегда выбирайте ConcurrentHashMap для высокопроизводительных сценариев с множеством потоков.
2. Читаемость vs Модифицируемость — если список преимущественно читается (listeners, snapshot данных), CopyOnWriteArrayList идеален. Если много изменений — лучше рассмотреть другие варианты.
3. Блокирующие vs Неблокирующие — если нужен паттерн Producer-Consumer с возможностью ожидания, выбирайте BlockingQueue. Для высокопроизводительных неблокирующих операций — ConcurrentLinkedQueue.
4. Контекст Kotlin Coroutines — в современных Android приложениях на Kotlin предпочтительнее использовать корутины и их инструменты (Channel, Flow, Mutex) вместо прямого использования JUC коллекций, так как они интегрированы с моделью отмены и структурированной конкуренции.

Пример использования в Android

// Пример безопасного кэша в сервисе
class Repository {
    private val cache = ConcurrentHashMap<String, Data>()
    
    fun getData(key: String): Data? {
        return cache[key]
    }
    
    fun updateData(key: String, data: Data) {
        cache[key] = data
    }
}

// Пример использования потокобезопасного списка для наблюдателей
class EventManager {
    private val listeners = CopyOnWriteArrayList<Listener>()
    
    fun addListener(listener: Listener) {
        listeners.add(listener)
    }
    
    fun notifyListeners(event: Event) {
        for (listener in listeners) { // Итерация безопасна
            listener.onEvent(event)
        }
    }
}

Заключение: Знание потокобезопасных коллекций и их правильного применения — обязательный навык для Android разработчика. Выбор конкретной реализации зависит от сценария использования: частоты чтения/записи, необходимости блокирующего поведения, контекста корутин и требований к производительности. Неправильный выбор может привести как к падению производительности, так и к сложным, трудноуловимым ошибкам в многопоточном коде.