Помнишь ли как работать с volatile

Помнишь ли как работать с volatile?

Да, volatile — это один из ключевых механизмов синхронизации в многопоточной Java. Это слово-модификатор для переменных, которое гарантирует видимость изменений между потоками и запрещает определённые оптимизации компилятором.

Что такое volatile?

volatile гарантирует, что:

1. Значение переменной всегда читается из памяти (не из кеша потока)
2. Изменение всегда видно другим потокам (immediate visibility)
3. Операции не переупорядочиваются (happens-before relationship)

Но volatile НЕ гарантирует atomicity — это критично понимать!

Базовый пример

// ❌ БЕЗ volatile — проблема видимости
public class ShutdownWithoutVolatile {
    private boolean shutdown = false;  // Может быть в кеше потока
    
    public void shutdown() {
        shutdown = true;  // Поток 1 изменил значение
    }
    
    public void work() {
        while (!shutdown) {  // Поток 2 может не видеть изменение!
            performTask();
        }
    }
}

// ✅ С volatile — работает корректно
public class ShutdownWithVolatile {
    private volatile boolean shutdown = false;  // Всегда из памяти
    
    public void shutdown() {
        shutdown = true;  // Поток 1 сразу видно в памяти
    }
    
    public void work() {
        while (!shutdown) {  // Поток 2 видит изменение сразу
            performTask();
        }
    }
}

Происходит без volatile

Поток 1:                       Память:           Поток 2:
shutdown = true;   →   ???    →   shutdown = false (может не видеть!)
  (записал в кеш)       (изменение не видно)    (читает из кеша)

Происходит с volatile

Поток 1:                       Память:           Поток 2:
shutdown = true;   →   shutdown = true   →   Видит true!
  (flush to memory)       (updated)             (reads from memory)

Важное уточнение: volatile НЕ гарантирует atomicity

Это самая частая ошибка! volatile гарантирует видимость, но НЕ гарантирует атомарность:

// ❌ НЕПРАВИЛЬНО — race condition!
public class CounterWithoutSync {
    private volatile int counter = 0;  // volatile НЕ спасает!
    
    public void increment() {
        counter++;  // Это НЕ атомарная операция!
        // На самом деле это: read → increment → write
        // Два потока могут прочитать одно значение,
        // оба инкрементировать, оба написать одно значение
    }
    
    public int getCounter() {
        return counter;
    }
}

// Тест покажет ошибку:
final CounterWithoutSync counter = new CounterWithoutSync();
for (int i = 0; i < 2; i++) {
    new Thread(() -> {
        for (int j = 0; j < 1000; j++) {
            counter.increment();
        }
    }).start();
}
Thread.sleep(1000);
System.out.println(counter.getCounter());  // Вместо 2000 выведет 1500-1900!

// ✅ ПРАВИЛЬНО — используй AtomicInteger
public class CounterWithAtomic {
    private final AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        counter.incrementAndGet();  // Атомарная операция!
    }
    
    public int getCounter() {
        return counter.get();
    }
}

Happens-Before Relationship

volatile создаёт порядок выполнения между потоками:

public class VolatileOrdering {
    private int x = 0;
    private volatile boolean ready = false;
    
    public void writer() {
        x = 42;              // Шаг 1
        ready = true;        // Шаг 2 (volatile write)
    }
    
    public void reader() {
        while (!ready) {}    // Ждём (volatile read)
        // Гарантированно x == 42!
        System.out.println(x);  // Выведет 42, а не 0!
    }
}

// volatile гарантирует порядок:
// writer() → Шаг 1 (x = 42) → Шаг 2 (ready = true) → reader() → читает x
// Шаг 1 ГАРАНТИРОВАННО выполнится ДО того, как reader прочитает ready!

Когда использовать volatile

1. Флаги шатдауна:

public class Service {
    private volatile boolean running = true;
    
    public void shutdown() {
        running = false;
    }
    
    public void run() {
        while (running) {
            doWork();
        }
    }
}

2. Двойная проверка блокировки (Double-Checked Locking):

public class Singleton {
    private static volatile Singleton instance;  // VOLATILE важен!
    
    public static Singleton getInstance() {
        if (instance == null) {                  // Проверка 1 (без lock)
            synchronized (Singleton.class) {
                if (instance == null) {          // Проверка 2 (с lock)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

3. Значения, которые читаются часто и пишутся редко:

public class ConfigManager {
    private volatile String apiKey;      // Читается много раз
    private volatile int maxConnections; // Пишется редко
    
    public String getApiKey() {
        return apiKey;  // Всегда свежее значение
    }
    
    public void updateConfig(String newKey, int newMax) {
        apiKey = newKey;
        maxConnections = newMax;
    }
}

Когда НЕ использовать volatile

❌ Для счётчиков:

// Плохо
private volatile int counter;
public void increment() {
    counter++;  // Race condition!
}

// Хорошо
private final AtomicInteger counter = new AtomicInteger();
public void increment() {
    counter.incrementAndGet();  // Атомарно
}

❌ Для объектов (только гарантирует видимость ссылки, не содержимого):

// Проблема: изменения внутри объекта НЕ видны другим потокам
private volatile MyObject obj;  // ← видимость ссылки
public void update() {
    obj.value = 10;  // ← изменение не видно другим потокам!
}

// Если нужна видимость полей объекта — используй synchronized или AtomicReference
private final Object lock = new Object();
private MyObject obj;
public void update() {
    synchronized (lock) {
        obj.value = 10;  // Теперь видно
    }
}

Сравнение механизмов синхронизации

// 1. volatile — самое быстрое, но только для видимости
private volatile boolean flag = false;
// Цена: ~1-2 нс за операцию, нет блокировки

// 2. synchronized — безопасно, но медленнее
private boolean flag = false;
synchronized (this) {
    flag = true;
}
// Цена: ~100-200 нс, может быть блокировка

// 3. AtomicInteger — оптимален для счётчиков
private final AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();
// Цена: ~10-20 нс, без блокировки, атомарно

// 4. ReentrantLock — гибкий synchronized
private final Lock lock = new ReentrantLock();
lock.lock();
try {
    // критическая секция
} finally {
    lock.unlock();
}
// Цена: ~50-100 нс, более гибкий чем synchronized

Практический пример: Правильная реализация

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private volatile boolean shutdown = false;
    private final Object lock = new Object();
    
    // Producer thread
    public void produce() throws InterruptedException {
        for (int i = 0; i < 100 && !shutdown; i++) {
            synchronized (lock) {
                queue.add(i);
                lock.notifyAll();  // Пробудить consumer
            }
        }
    }
    
    // Consumer thread
    public void consume() throws InterruptedException {
        while (!shutdown) {
            synchronized (lock) {
                while (queue.isEmpty() && !shutdown) {
                    lock.wait();  // Ждём сигнала
                }
                if (!queue.isEmpty()) {
                    Integer value = queue.poll();
                    System.out.println("Consumed: " + value);
                }
            }
        }
    }
    
    public void shutdown() {
        shutdown = true;  // volatile flag
        synchronized (lock) {
            lock.notifyAll();  // Пробудить всех
        }
    }
}

// Разбор:
// - volatile boolean shutdown → для видимости флага
// - synchronized + lock.wait() → для coordination между потоками
// - Это правильная комбинация!

Memory Visibility в Java (кратко)

// Java Memory Model гарантирует:

1. volatile writes → volatile reads   (видимость)
2. synchronized exit → synchronized entry (видимость)
3. thread.start() → действия в потоке (видимость)
4. действия в потоке → thread.join() (видимость)
5. finalField writes → reads (видимость для final)

Заключение

volatile используется для:

• ✅ Простых флагов (boolean shutdown)
• ✅ Конфигурационных значений
• ✅ Гарантирования видимости между потоками

НЕ используется для:

• ❌ Счётчиков (используй AtomicInteger)
• ❌ Сложных операций (используй synchronized или ReentrantLock)
• ❌ Изменений внутри объектов (volatile гарантирует видимость ссылки, не содержимого)

Золотое правило: Если нужна ТОЛЬКО видимость без блокировки → volatile. Если нужна атомарность или координация → synchronized, AtomicInteger или ReentrantLock.

volatile — это микроскопический инструмент для конкретной задачи, а не универсальное решение для многопоточности.