Как несколько потоков получают актуальное значение переменной, помеченной volatile

Как несколько потоков получают актуальное значение переменной, помеченной volatile

Это фундаментальный вопрос о многопоточности в Java. Volatile гарантирует видимость изменений переменной для всех потоков.

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

Когда переменная не помечена как volatile, компилятор и CPU могут кешировать её значение локально в регистре потока:

public class Counter {
    private int count = 0; // БЕЗ volatile
    
    public void increment() {
        count++; // Поток 1 может кешировать count = 0 в своём регистре
    }
    
    public int getCount() {
        return count; // Поток 2 может получить устаревшее значение
    }
}

// Поток 1: count = 0, increment (реально 1, но в регистре 0)
// Поток 2: читает count из памяти, видит 0 вместо 1 - видимость нарушена

Решение: volatile ключевое слово

public class Counter {
    private volatile int count = 0; // С volatile
    
    public void increment() {
        count++; // Изменение сразу видно в основной памяти
    }
    
    public int getCount() {
        return count; // Читается свежее значение из основной памяти
    }
}

Как работает volatile

Volatile работает через Memory Barriers (барьеры памяти):

Основная память:
[count = 0]
      |
      | (Cache in CPU)
      |
Поток 1 регистр: [0]
Поток 2 регистр: [0]

Без volatile:
- Поток 1 читает count = 0 в регистр (кеширует)
- Поток 1 изменяет регистр на 1, но НЕ пишет в память
- Поток 2 читает из регистра = 0 (видит устаревшее значение)

С volatile:
- Поток 1 читает count = 0
- Поток 1 изменяет на 1
- Memory Barrier заставляет записать 1 в основную память
- Инвалидирует кеш других потоков
- Поток 2 вынужден читать из основной памяти = 1 (видит актуальное значение)

Практический пример

public class StopFlag {
    private volatile boolean shouldStop = false;
    
    public void stop() {
        shouldStop = true; // Сразу видно всем потокам
    }
    
    public void work() {
        while (!shouldStop) { // Всегда читаем актуальное значение
            doSomething();
        }
    }
}

// Использование
StopFlag flag = new StopFlag();

// Поток 1
Thread worker = new Thread(() -> flag.work());
worker.start();

// Основной поток (через 5 сек)
Thread.sleep(5000);
flag.stop(); // Рабочий поток сразу это увидит

Видимость памяти: Happens-Before отношения

Volatile создаёт happens-before отношения:

public class VolatileExample {
    private volatile boolean ready = false;
    private int value = 0;
    
    public void writer() {
        value = 42;          // Пишем обычную переменную
        ready = true;        // Пишем в volatile (memory barrier)
    }
    
    public void reader() {
        if (ready) {         // Читаем из volatile (memory barrier)
            int x = value;   // Гарантированно 42, не 0
        }
    }
}

// Happens-before:
// 1. value = 42 happens-before ready = true
// 2. ready = true happens-before if (ready)
// 3. if (ready) happens-before int x = value
// Результат: поток reader ГАРАНТИРОВАННО видит value = 42

Механизм на уровне CPU

Volatile использует CPU инструкции с барьерами:

// Volatile write: volatile int x = 5;
// Компилируется в:
//   mov [address], eax      // Запись в памяти
//   mfence                  // Memory Fence (барьер)

// Volatile read: int x = volatile_var;
// Компилируется в:
//   mfence                  // Memory Fence
//   mov eax, [address]      // Чтение из памяти

Ограничения volatile

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

1. Атомарность операций
2. Исключительный доступ

public class BrokenCounter {
    private volatile int count = 0;
    
    public void increment() {
        count++; // НЕ атомарно! (read -> modify -> write)
    }
    // Два потока могут оба прочитать 0, оба сделать count=1
}

// Правильно:
public class CorrectCounter {
    private volatile int count = 0;
    
    public synchronized void increment() {
        count++; // Теперь атомарно
    }
}

// Или использовать AtomicInteger
public class BetterCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // Атомарно
    }
}

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

✅ Подходит для:

• Флаги состояния (boolean stop, ready, etc)
• Простые переменные, которые читаются намного чаще, чем пишутся
• Легкие счётчики когда порядок записей не критичен

❌ НЕ подходит для:

• Операций, которые требуют атомарности (i++, x = x + 1)
• Объектов со сложным состоянием
• Когда нужна взаимная исключительность

Сравнение подходов

// 1. Volatile (лёгкий, но НЕ атомарный)
private volatile int count = 0;
public void increment() { count++; } // НЕПРАВИЛЬНО!

// 2. Synchronized (тяжелый, но безопасный)
private int count = 0;
public synchronized void increment() { count++; } // OK

// 3. AtomicInteger (оптимальный для счётчиков)
private final AtomicInteger count = new AtomicInteger(0);
public void increment() { count.incrementAndGet(); } // OK

// 4. ReentrantReadWriteLock (много читателей)
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private int count = 0;
public void increment() {
    lock.writeLock().lock();
    try { count++; }
    finally { lock.writeLock().unlock(); }
}

Производительность

Операция 100 млн раз на Intel i7:
- volatile read: ~50ms
- synchronized: ~500ms (10x медленнее)
- volatile write: ~100ms
- AtomicInteger.incrementAndGet(): ~150ms

Volatile очень быстрая, но помни о happens-before отношениях!

Java Memory Model (JMM)

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

1. Atomicity: volatile reads/writes атомарны
2. Visibility: volatile writes видны всем последующим reads
3. Ordering: volatile создаёт памятные барьеры

Итоги

1. Volatile гарантирует видимость изменений для всех потоков
2. Используется через Memory Barriers (барьеры памяти)
3. Пишут в память сразу, читают из памяти всегда
4. НЕ гарантирует атомарность сложных операций
5. Для счётчиков используй AtomicInteger, не volatile int
6. Для флагов и состояния volatile достаточно