Каковы другие способы борьбы с гонками потоков, кроме использования ключевого слова volatile?

Синхронизация (synchronized): Ключевое слово synchronized обеспечивает атомарность выполнения блоков кода или методов. Только один поток может выполнять синхронизированный блок/метод для данного объекта в любой момент времени.

// Синхронизированный метод
public synchronized void incrementCounter() {
    counter++;
}

// Синхронизированный блок
public void updateValue(int newValue) {
    synchronized (this) {
        value = newValue;
    }
}

Блокировки (Locks): Более гибкий механизм по сравнению с synchronized. Позволяет управлять блокировкой явно, используя методы lock() и unlock(). Обычно используются реализации интерфейса Lock из пакета java.util.concurrent.locks, например ReentrantLock.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // Получение блокировки
        try {
            count++;
        } finally {
            lock.unlock(); // Освобождение блокировки
        }
    }
}

Атомарные переменные (Atomic Variables): Классы из пакета java.util.concurrent.atomic (например, AtomicInteger, AtomicLong, AtomicReference). Они предоставляют атомарные операции над одиночными переменными, используя низкоуровневые инструкции процессора (Compare-And-Swap - CAS), что часто более эффективно, чем блокировка.

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Атомарное увеличение
    }
}

Concurrent Collections: Потокобезопасные коллекции из пакета java.util.concurrent (например, ConcurrentHashMap, CopyOnWriteArrayList). Они разработаны для поддержки многопоточного доступа без явной синхронизации со стороны пользователя, часто используя внутренние механизмы блокировки или оптимизированные алгоритмы.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class SharedCache {
    private final Map<String, String> cache = new ConcurrentHashMap<>();

    public void put(String key, String value) {
        cache.put(key, value);
    }

    public String get(String key) {
        return cache.get(key);
    }
}

Immutable Objects: Использование неизменяемых объектов устраняет необходимость синхронизации, поскольку их состояние не может быть изменено после создания. Неизменяемые объекты inherently thread-safe.

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

ThreadLocal Variables: Предоставляют способ хранения переменных, которые доступны только текущему потоку. Каждый поток имеет свою собственную независимую копию переменной. Это устраняет проблемы конкурентного доступа, так как данные не разделяются между потоками.

import java.lang.ThreadLocal;

public class ThreadSpecificData {
    private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(() -> (int) Thread.currentThread().getId());

    public static Integer getThreadId() {
        return threadId.get();
    }
}

Диспетчеры (Dispatchers) / Исполнители (Executors): В Android-разработке часто используются диспетчеры (например, Dispatchers в Kotlin Coroutines) или исполнители (например, ExecutorService в Java) для управления выполнением задач на определенных потоках или пулах потоков. Правильное использование этих механизмов может изолировать изменения состояния на одном потоке, избегая гонок.

// Пример с Kotlin Coroutines
import kotlinx.coroutines.*

fun updateUI() {
    GlobalScope.launch(Dispatchers.Main) {
        // Код, изменяющий UI, выполняется на главном потоке
    }
}

// Пример с ExecutorService
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BackgroundTask {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    public void performOperation() {
        executor.submit(() -> {
            // Дорогостоящая операция выполняется на отдельном потоке
        });
    }
}