Что лучше использовать при изменении переменной из разных потоков Volatile, Atomic или synchronized

Управление состоянием в многопоточной среде: Volatile, Atomic и Synchronized

При изменении переменной из разных потоков выбор между volatile, Atomic классами и synchronized зависит от конкретной операции и требований к атомарности, видимости изменений и производительности. Это фундаментальный вопрос многопоточности в Java/Android, требующий понимания модели памяти JVM.

Основные концепции и различия

volatile

Ключевая роль: Гарантия видимости изменений между потоками и предотвращение reordering оптимизаций компилятора.

• Атомарность: НЕ гарантирует атомарность сложных операций (например, i++). Чтение и запись самой переменной атомарны для long/double, но инкремент состоит из чтения, изменения и записи.
• Видимость: Когда один поток записывает значение в volatile переменную, оно сразу становится видимым всем другим потокам.
• Сценарий использования: Идеально для простых флагов состояния или переменных, где важна мгновенная видимость, но не требуется атомарность составных операций.

// Пример: Использование volatile для флага остановки
public class WorkerThread {
    private volatile boolean isStopped = false;

    public void stop() {
        isStopped = true; // Запись видна всем потокам сразу
    }

    public void run() {
        while (!isStopped) { // Чтение всегда получает последнее значение
            // Выполнение работы
        }
    }
}

Atomic классы (AtomicInteger, AtomicLong, AtomicBoolean)

Ключевая роль: Гарантия атомарности операций над переменной с использованием низкоуровневых механизмов (часто CAS - Compare-And-Swap) без явной блокировки.

• Атомарность: Предоставляют атомарные операции (incrementAndGet(), compareAndSet(), addAndGet()).
• Видимость: Внутренняя реализация также обеспечивает видимость изменений (использует volatile внутри и более строгие гарантии).
• Сценарий использования: Оптимальны для частых атомарных операций над одним значением (счетчики, флаги), где нужна атомарность, но минимальные накладные расходы.

// Пример: AtomicInteger для счетчика из нескольких потоков
public class CounterService {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Атомарная операция, безопасная для потоков
    }

    public int getCount() {
        return count.get();
    }
}

synchronized

Ключевая роль: Гарантия полной атомарности и видимости через приобретение монитора объекта, что обеспечивает взаимное исключение и синхронизацию памяти.

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

// Пример: synchronized для сложной атомарной операции
public class BankAccount {
    private int balance;

    public synchronized void transfer(int amount) {
        // Атомарно изменяем баланс, защищая от race condition
        if (balance >= amount) {
            balance -= amount;
        }
    }
}

Сравнение и рекомендации

Критерии выбора

1. Требования к атомарности операции:

   • Простая запись/чтение одного значения → volatile.
   • Атомарная операция над одним значением (инкремент, сложение) → Atomic классы.
   • Комплексная операция с несколькими переменными или логикой → synchronized.

2. Производительность и накладные расходы:

   • volatile → минимальные накладные расходы (только гарантии памяти).
   • Atomic → обычно более эффективны, чем synchronized, особенно при низкой конкуренции (используют CAS, избегая блокировки).
   • synchronized → более тяжеловесный (блокировка потока, возможные очереди), но универсальный.

3. Сложность и читаемость кода:

   • Atomic классы часто делают код более чистым для простых атомарных операций.
   • synchronized может быть понятнее для сложных блоков логики.

Практические рекомендации для Android

• Для флагов состояния (например, isLoading, isCancelled) чаще используйте AtomicBoolean или volatile boolean.
• Для счетчиков, прогресса (например, количество загруженных элементов) предпочтительны AtomicInteger / AtomicLong.
• Для синхронизации сложных операций или доступа к коллекциям часто требуется synchronized или более высокоуровневые механизмы (Lock, ConcurrentHashMap).
• Помните о Android специфике: некоторые атомарные операции могут быть менее эффективными на устройствах со слабыми процессорами, но в целом рекомендации соответствуют Java.

Важные предостережения

• volatile НЕ решает проблему атомарности составных операций. Операция volatileVar++ все еще опасна в многопоточном контексте.
• Atomic классы могут страдать от проблем ABA в CAS операциях, но для большинства случаев это не критично.
• synchronized может вызывать deadlocks при неправильном использовании, требует внимательного дизайна.

Итог: Выбор инструмента зависит от конкретной задачи: volatile для видимости, Atomic для атомарных операций над одним значением, synchronized для сложной атомарности или блокировки ресурсов. Для большинства случаев с атомарными изменениями одного значения Atomic классы являются оптимальным балансом безопасности, производительности и читаемости кода.