Является ли AtomicInteger volatile?

Является ли AtomicInteger volatile?

Это интересный и часто задаваемый вопрос на собеседованиях. Ответ требует понимания различия между механизмом volatile и гарантиями, которые предоставляет AtomicInteger. Если кратко: AtomicInteger НЕ использует модификатор volatile, но ОБЕСПЕЧИВАЕТ аналогичные гарантии видимости через внутренние механизмы.

Что такое volatile?

Volatile — это модификатор в Java, который гарантирует:

1. Visibility (видимость) — изменения в одном потоке сразу видны другим потокам
2. Happens-before отношение — операции с volatile переменной имеют четкий порядок

// Пример volatile переменной
public class VolatileExample {
    private volatile boolean flag = false;
    
    public void setFlag() {
        flag = true;  // Изменение видно всем потокам
    }
    
    public boolean getFlag() {
        return flag;  // Читаем текущее значение
    }
}

Внутреннее устройство AtomicInteger

Атомик классы используют unsafe операции и volatile внутри, но сама переменная объявлена как volatile:

// Упрощенная реализация AtomicInteger (Java source)
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    
    private volatile int value;  // ← Вот она! volatile
    
    static {
        try {
            valueOffset = unsafe.objectFieldOffset(
                AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    public final int get() {
        return value;
    }
    
    public final void set(int newValue) {
        value = newValue;
    }
    
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
}

Да, внутренняя переменная value в AtomicInteger действительно volatile!

Разница между volatile и AtomicInteger

Хотя оба используют volatile, они гарантируют разные уровни безопасности:

Volatile переменная

private volatile int counter = 0;

// ПРОБЛЕМА: race condition!
public void increment() {
    counter++;  // ← три операции: прочитать, увеличить, записать
}

Это не атомарно! Три операции могут быть прерваны другим потоком:

Поток 1: прочитал 5
Поток 2: прочитал 5
Поток 1: увеличил до 6 и записал
Поток 2: увеличил до 6 и записал ← должно было быть 7!

AtomicInteger

private AtomicInteger counter = new AtomicInteger(0);

// Безопасно для multi-threading!
public void increment() {
    counter.incrementAndGet();  // ← Одна атомарная операция
}

Пример: правильное использование AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class CounterExample {
    private AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        counter.incrementAndGet();
    }
    
    public int getCount() {
        return counter.get();
    }
    
    public static void main(String[] args) throws InterruptedException {
        CounterExample example = new CounterExample();
        
        // Создаем 10 потоков
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    example.increment();
                }
            });
        }
        
        // Запускаем все потоки
        for (Thread t : threads) {
            t.start();
        }
        
        // Ждем завершения
        for (Thread t : threads) {
            t.join();
        }
        
        System.out.println("Final count: " + example.getCount());
        // Output: Final count: 10000 ✓ Всегда правильно!
    }
}

Сравним с volatile:

private volatile int counter = 0;

// НЕ безопасно!
public void increment() {
    counter++;
}

// Output: Final count: 9997 ✗ Неправильно!

Внутренний механизм: CAS (Compare-And-Swap)

AtomicInteger использует CAS операции для атомарности:

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

Это работает так:

1. Читаем текущее значение (например, 5)
2. Вычисляем новое значение (6)
3. Атомарно сравниваем: если значение еще 5, записываем 6
4. Если другой поток изменил значение, повторяем с шага 1

Другие атомарные классы

Java предоставляет семейство атомарных классов в пакете java.util.concurrent.atomic:

private AtomicBoolean ready = new AtomicBoolean(false);
private AtomicLong timestamp = new AtomicLong(0);
private AtomicReference<String> name = new AtomicReference<>("initial");
private AtomicIntegerArray array = new AtomicIntegerArray(10);

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

Используй AtomicInteger когда:

• Нужна простая численная переменная с thread-safe операциями
• Требуется атомарная обновления (increment, decrement, CAS)
• Хочешь избежать синхронизации
• Работаешь со счетчиками, флагами в multi-threaded коде

Используй synchronized когда:

• Нужна сложная логика с несколькими переменными
• Требуется блокировка раздела кода
• Нужно обновить несколько полей атомарно

Заключение

AtomicInteger НЕ объявляется как volatile на уровне класса, но его внутренняя переменная value является volatile, обеспечивая видимость. Кроме того, AtomicInteger предоставляет дополнительные гарантии атомарности через CAS операции, которых нет у простых volatile переменных. Это делает его безопасным выбором для thread-safe счетчиков и простых операций без необходимости использования синхронизации.