Что решает volatile?

Ключевое слово volatile

Volatile решает проблему видимости (visibility) данных между потоками в контексте Java Memory Model. Расскажу подробно о проблеме и решении.

Проблема без volatile

Пример проблемы:

public class VisibilityProblem {
    private boolean flag = false;  // Обычная переменная
    
    public void writer() {
        flag = true;  // Поток 1 устанавливает флаг
    }
    
    public void reader() {
        while (!flag) {  // Поток 2 ждёт флаг
            // spin-loop
        }
        System.out.println("Flag was set!");
    }
}

Что происходит:

1. Поток 1 устанавливает flag = true в своём локальном кеше (CPU cache L1/L2)
2. Поток 2 читает flag из своего кеша процессора
3. Значение не синхронизируется между кешами
4. Поток 2 никогда не видит true и бесконечно крутится в loop

Java Memory Model (JMM)

JVM гарантирует следующее:

┌─────────────────┐         ┌─────────────────┐
│   Поток 1       │         │   Поток 2       │
│ ┌─────────────┐ │         │ ┌─────────────┐ │
│ │ L1 cache    │ │         │ │ L1 cache    │ │
│ │ flag=true   │ │         │ │ flag=false  │ │
│ └─────────────┘ │         │ └─────────────┘ │
│        ↓        │         │        ↓        │
│    CPU cache    │         │    CPU cache    │
└────────┬────────┘         └────────┬────────┘
         │                           │
         └───────────┬───────────────┘
                     ↓
            ┌─────────────────┐
            │  Main Memory    │
            │  flag = ???     │
            └─────────────────┘

Решение: volatile

public class VisibilitySolved {
    private volatile boolean flag = false;  // Volatile решает проблему
    
    public void writer() {
        flag = true;  // Гарантированно пишет в main memory
    }
    
    public void reader() {
        while (!flag) {  // Гарантированно читает из main memory
            // spin-loop
        }
        System.out.println("Flag was set!");
    }
}

Что гарантирует volatile:

1. Visibility (видимость):

   • Запись в volatile переменную гарантированно попадает в main memory
   • Чтение из volatile переменной берёт значение из main memory

2. Happens-Before отношение:

   • Запись в volatile случается раньше любого последующего чтения этой переменной

Семантика volatile

Write-Release:

volatile boolean flag = false;

flag = true;  // Это запись в volatile
// Гарантированно: все операции ДО этой строки видны другим потокам

Read-Acquire:

while (!flag) {  // Это чтение из volatile
    // Гарантированно: видим все операции, которые случились ДО записи
}

Что volatile НЕ решает

Атомарность:

public class CounterProblem {
    private volatile int counter = 0;
    
    public void increment() {
        counter++;  // ❌ NOT atomic!
        // Это три операции:
        // 1. Read current value
        // 2. Add 1
        // 3. Write new value
        // Между ними другой поток может вставить свою операцию
    }
}

// Проблема Race Condition
Thread t1 -> counter = 0, читает 0, пишет 1
Thread t2 -> counter = 0, читает 0, пишет 1
// Вместо 2, будет 1!

Решение — AtomicInteger:

public class CounterFixed {
    private AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        counter.incrementAndGet();  // ✅ Атомарная операция
    }
}

Примеры использования volatile

1. Double-Checked Locking (Singleton с ленивой инициализацией):

public class Singleton {
    private static volatile Singleton instance;  // volatile!
    
    public static Singleton getInstance() {
        if (instance == null) {  // First check (no locking)
            synchronized (Singleton.class) {
                if (instance == null) {  // Second check (with locking)
                    instance = new Singleton();  // Safe initialization
                }
            }
        }
        return instance;
    }
}

Без volatile:

• Поток 1 создаёт Singleton и пишет ссылку в своём кеше
• Поток 2 видит null в своём кеше (хотя Singleton уже создан)
• Поток 2 пытается создать свой экземпляр
• Результат: несколько экземпляров

С volatile:

• Гарантированно видим правильное значение

2. Флаги остановки (shutdown flags):

public class WorkerThread extends Thread {
    private volatile boolean stopped = false;  // volatile флаг
    
    public void run() {
        while (!stopped) {  // Гарантированно видим обновления
            doWork();
        }
    }
    
    public void stopWorker() {
        stopped = true;  // Другой поток установит флаг
    }
}

// Использование
WorkerThread worker = new WorkerThread();
worker.start();
Thread.sleep(1000);
worker.stopWorker();  // Безопасная остановка
worker.join();

3. Config reloading:

public class ConfigService {
    private volatile Map<String, String> config;
    
    public String getConfig(String key) {
        return config.get(key);  // Всегда видим последнюю версию
    }
    
    public void reloadConfig() {
        Map<String, String> newConfig = loadFromFile();
        this.config = newConfig;  // Атомарно обновляем
    }
}

Performance implications

Стоимость volatile:

1. Memory barriers:

   • Запись в volatile требует flush всех кешей
   • Чтение требует refresh из main memory
   • Дороже обычного чтения/записи (~10-100x медленнее)

2. CPU optimization limitations:

   • Процессор не может оптимизировать операции вокруг volatile
   • Нет reordering инструкций

// С volatile переменной:
volatile boolean flag = false;
int x = 5;

flag = true;  // Memory barrier
x = 10;  // Не может быть переупорядочено ДО flag = true

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

✅ Используй volatile:

• Простые флаги (boolean)
• Ссылки на объекты (но не сам объект)
• Значения, которые читаются/пишутся из разных потоков
• Когда тебе нужна только видимость, не атомарность

❌ Не используй volatile:

• Вместо synchronized для сложной логики
• Вместо AtomicInteger/AtomicLong для операций типа ++
• Для защиты всего объекта целиком

Альтернативы volatile

1. synchronized:

private int counter = 0;

public synchronized void increment() {
    counter++;  // Явно синхронизируем
}

2. Atomic classes:

private AtomicInteger counter = new AtomicInteger(0);

public void increment() {
    counter.incrementAndGet();
}

3. ReentrantLock:

private Lock lock = new ReentrantLock();
private int counter = 0;

public void increment() {
    lock.lock();
    try {
        counter++;
    } finally {
        lock.unlock();
    }
}

Итого

volatile решает:

1. Видимость (visibility) данных между потоками
2. Гарантирует, что запись видна другим потокам немедленно
3. Гарантирует happens-before отношение

volatile НЕ решает:

1. Атомарность сложных операций (++, += и т.д.)
2. Синхронизацию доступа к объектам
3. Защиту от race conditions

Используй volatile для:

• Простых флагов и значений
• Когда нужна только видимость, не синхронизация

Используй synchronized/AtomicInteger для:

• Сложных операций
• Когда нужна атомарность