Какие знаешь варианты решения проблемы гонки потоков кроме mutex?

Варианты решения проблемы гонки потоков (Race Condition) помимо Mutex

Проблема гонки потоков возникает, когда несколько потоков одновременно обращаются к общим данным, и хотя бы один из них выполняет запись. Помимо классического mutex (взаимного исключения), существует множество других подходов и примитивов синхронизации в Android/Kotlin/Java.

1. Atomic-типы (java.util.concurrent.atomic)

Атомарные классы обеспечивают потокобезопасные операции над переменными без явных блокировок, используя low-level механизмы процессора (CAS – Compare-And-Swap).

import java.util.concurrent.atomic.AtomicInteger

class Counter {
    private val count = AtomicInteger(0)
    
    fun increment() {
        count.incrementAndGet() // Атомарная операция
    }
    
    fun getValue(): Int = count.get()
}

• Преимущества: Высокая производительность для простых операций (инкремент, декремент, обновление).
• Недостатки: Подходят только для отдельных переменных, а не для сложных составных операций.

2. Потокобезопасные коллекции (java.util.concurrent)

Вместо синхронизации обычных коллекций (например, Collections.synchronizedList()) лучше использовать специализированные конкурентные коллекции.

import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.ConcurrentHashMap

// Потокобезопасный список (оптимизирован для частого чтения)
val threadSafeList = CopyOnWriteArrayList<String>()

// Высокопроизводительная потокобезопасная хэш-таблица
val concurrentMap = ConcurrentHashMap<String, Int>()

• CopyOnWriteArrayList: Создает копию массива при изменении, подходит для редких записей.
• ConcurrentHashMap: Использует сегментированную блокировку (lock striping) для высокой параллельности.

3. Семафоры (Semaphore)

Ограничивают количество потоков, которые могут одновременно обращаться к ресурсу.

import java.util.concurrent.Semaphore

class ResourcePool(private val maxConnections: Int) {
    private val semaphore = Semaphore(maxConnections)
    
    fun useResource() {
        semaphore.acquire() // Получаем разрешение
        try {
            // Работа с ресурсом
        } finally {
            semaphore.release() // Всегда освобождаем
        }
    }
}

• Применение: Ограничение подключений к БД, пулы ресурсов.

4. Барьеры (CyclicBarrier, CountDownLatch)

Координируют выполнение нескольких потоков в определенных точках.

import java.util.concurrent.CyclicBarrier

class ParallelProcessor(val workerCount: Int) {
    private val barrier = CyclicBarrier(workerCount) {
        // Выполнится, когда все потоки дойдут до барьера
        println("All workers reached barrier")
    }
    
    fun process() {
        // Каждый поток выполняет свою часть работы
        // ...
        barrier.await() // Ждем остальные потоки
        // Продолжаем синхронно
    }
}

• CyclicBarrier: Многоразовый барьер для синхронизации N потоков.
• CountDownLatch: Одноразовый барьер, где потоки ждут завершения операций.

5. ReadWriteLock (ReentrantReadWriteLock)

Позволяет нескольким потокам одновременно читать данные, но блокирует для записи.

import java.util.concurrent.locks.ReentrantReadWriteLock

class ThreadSafeCache<K, V> {
    private val cache = mutableMapOf<K, V>()
    private val lock = ReentrantReadWriteLock()
    
    fun get(key: K): V? {
        lock.readLock().lock() // Много потоков могут читать одновременно
        try {
            return cache[key]
        } finally {
            lock.readLock().unlock()
        }
    }
    
    fun put(key: K, value: V) {
        lock.writeLock().lock() // Только один поток может писать
        try {
            cache[key] = value
        } finally {
            lock.writeLock().unlock()
        }
    }
}

• Преимущества: Повышает производительность при частом чтении.
• Недостатки: Может привести к голоданию писателей при активном чтении.

6. Специфичные для Kotlin подходы

Корутины с мьютексами и акторами

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

val mutex = Mutex()

suspend fun safeUpdate() {
    mutex.withLock { // Suspending mutex для корутин
        // Критическая секция
    }
}

Актор (Actor) паттерн

import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.actor

sealed class CounterMessage
object Increment : CounterMessage()
class GetValue(val response: CompletableDeferred<Int>) : CounterMessage()

fun counterActor() = GlobalScope.actor<CounterMessage> {
    var count = 0
    for (msg in channel) {
        when (msg) {
            is Increment -> count++
            is GetValue -> msg.response.complete(count)
        }
    }
}

Актор инкапсулирует состояние и обрабатывает сообщения последовательно, исключая гонки.

7. Неблокирующие алгоритмы (Lock-free)

Используют атомарные операции и careful memory ordering для реализации структур данных без блокировок.

// Пример lock-free стека (упрощенный)
import java.util.concurrent.atomic.AtomicReference

class LockFreeStack<T> {
    private data class Node<T>(val value: T, val next: Node<T>?)
    
    private val head = AtomicReference<Node<T>?>(null)
    
    fun push(value: T) {
        val newNode = Node(value, head.get())
        while (!head.compareAndSet(newNode.next, newNode)) {
            newNode.next = head.get()
        }
    }
}

• Преимущества: Устойчивость к deadlocks, высокая производительность.
• Недостатки: Сложность реализации и отладки.

8. ThreadLocal переменные

Каждый поток работает со своей копией переменной.

private val threadLocalCounter = ThreadLocal.withInitial { 0 }

fun threadSpecificOperation() {
    val localValue = threadLocalCounter.get()
    threadLocalCounter.set(localValue + 1)
    // Каждый поток имеет свою независимую копию
}

Критерии выбора подхода

1. Производительность: Для счетчиков - atomic, для чтения/записи - ReadWriteLock
2. Сложность данных: Простые типы - atomic, коллекции - потокобезопасные аналоги
3. Паттерны доступа: Много чтения - CopyOnWrite, равномерный доступ - ConcurrentHashMap
4. Координация потоков: Семафоры для ограничения, барьеры для синхронизации
5. Уровень абстракции: Корунтины - suspending mutex/акторы, обычные потоки - java.util.concurrent

Важно: Всегда предпочитайте неизменяемые (immutable) данные там, где это возможно, и минимизируйте общее изменяемое состояние между потоками, так как это наиболее надежный способ избежать гонок.