Решает ли ключевое слово volatile проблему Race Condition

Volatile и Race Conditions в многопоточности

Ответ: volatile частично решает проблему Race Condition, но не полностью. Важно понимать, что он делает и когда его использовать.

Что делает volatile

Volatile гарантирует:

1. Видимость (Visibility) — изменения одного потока видны другим
2. Порядок операций (Ordering) — заказ операций в памяти

НО не гарантирует:

• Атомарность (Atomicity) — неделимость операции

Проблема Race Condition

public class Counter {
    private int count = 0; // БЕЗ volatile — опасно!
    
    public void increment() {
        count++; // Это НЕ атомарная операция!
    }
    
    public int getCount() {
        return count;
    }
}

Операция count++ состоит из трёх шагов:

1. Прочитать значение (READ)
2. Увеличить на 1 (COMPUTE)
3. Написать обратно (WRITE)

Если два потока выполняют это одновременно:

Поток 1: READ (count=5)  → COMPUTE (5+1=6)  → WRITE (count=6)
Поток 2: READ (count=5)  → COMPUTE (5+1=6)  → WRITE (count=6)

Результат: count=6, хотя должно быть 7!

Это Race Condition.

Помогает ли volatile?

public class Counter {
    private volatile int count = 0; // С volatile
    
    public void increment() {
        count++; // Всё ещё НЕ атомарна!
    }
    
    public int getCount() {
        return count;
    }
}

Нет, volatile НЕ решает эту проблему!

Volatile только гарантирует видимость, но не атомарность. Race Condition остаётся.

Когда volatile ТА РАБОТАЕТ

Пример 1: Простое присваивание (атомарное в Java)

public class Flag {
    private volatile boolean isRunning = true;
    
    public void stop() {
        isRunning = false; // Атомарная операция
    }
    
    public boolean isRunning() {
        return isRunning; // Атомарная операция
    }
}

Здесь volatile РАБОТАЕТ, потому что чтение и запись одного boolean — атомарные.

Пример 2: Ссылка на объект

public class Cache {
    private volatile Object cachedValue; // Ссылка атомарна
    
    public void setCachedValue(Object value) {
        this.cachedValue = value; // Атомарно
    }
    
    public Object getCachedValue() {
        return cachedValue; // Атомарно
    }
}

Здесь volatile РАБОТАЕТ.

Решения для Race Condition

Вариант 1: Synchronized (Синхронизация)

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++; // Теперь атомарно
    }
    
    public synchronized int getCount() {
        return count;
    }
}

Минусы: может быть медленно при большой конкуренции.

Вариант 2: AtomicInteger (Рекомендуется)

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // Атомарно!
    }
    
    public int getCount() {
        return count.get();
    }
}

Преимущества: быстрее чем synchronized, потокобезопасно.

Вариант 3: ReentrantReadWriteLock (для сложных операций)

public class SharedData {
    private int value;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void updateValue(int newValue) {
        lock.writeLock().lock();
        try {
            // Критическая секция для записи
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public int getValue() {
        lock.readLock().lock();
        try {
            // Критическая секция для чтения
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }
}

Визуализация проблем

╔════════════════════════════════════════════════════╗
║             Видимость (Visibility)                 ║
├────────────────────────────────────────────────────┤
║ Обычная переменная:                                ║
║ Поток 1 пишет → может быть невидимо для Потока 2  ║
║                                                     ║
║ Volatile переменная:                               ║
║ Поток 1 пишет → ВИДИМО для Потока 2               ║
╚════════════════════════════════════════════════════╝

╔════════════════════════════════════════════════════╗
║            Атомарность (Atomicity)                 ║
├────────────────────────────────────────────────────┤
║ count++  состоит из 3 операций                     ║
║ Даже с volatile МОЖЕТ быть race condition          ║
║                                                     ║
║ count = 10  одна операция                          ║
║ С volatile БЕЗ race condition                      ║
╚════════════════════════════════════════════════════╝

Ключевые выводы

• Volatile решает проблему видимости, не атомарности
• Volatile ПОМОГАЕТ только для простых атомарных операций (присваивание)
• Volatile НЕ ПОМОГАЕТ для составных операций (count++, если-то-то)
• Используй AtomicInteger/Long/Boolean вместо synchronized для счётчиков
• Используй synchronized только если нужна критическая секция
• Используй ReentrantLock для продвинутых сценариев
• Правило: если сомневаешься — используй AtomicInteger, это безопаснее и быстрее