На основе чего построены Atomic классы

Atomic классы: основание и реализация

Аtomic классы (AtomicInteger, AtomicLong, AtomicReference и т.д.) — это основа lock-free программирования в Java. Разберёмся, на чём они построены.

Основание: CAS операция (Compare-And-Swap)

Atomic классы построены на CAS — это операция на уровне процессора:

// Концепция CAS (не реальный код):
boolean compareAndSwap(long expectedValue, long newValue) {
    // Атомарно (на уровне CPU):
    if (this.value == expectedValue) {
        this.value = newValue;
        return true;
    }
    return false;
}

Ключевое свойство: CAS выполняется атомарно на уровне процессора — без блокировок (lock-free)!

Примеры Atomic классов

// ✅ Атомарный Integer
AtomicInteger counter = new AtomicInteger(0);
int oldValue = counter.getAndIncrement();  // Вернёт 0, увеличит на 1
int newValue = counter.get();               // Вернёт 1

// ✅ Атомарный Long
AtomicLong timestamp = new AtomicLong(System.currentTimeMillis());
timestamp.compareAndSet(expectedTime, newTime);

// ✅ Атомарный Reference (для объектов)
AtomicReference<String> reference = new AtomicReference<>("initial");
reference.compareAndSet("initial", "updated");

// ✅ Атомарный Array
AtomicIntegerArray array = new AtomicIntegerArray(100);
array.getAndIncrement(5);  // Атомарно увеличит элемент [5]

Внутренняя реализация: Unsafe класс

Atomic классы используют sun.misc.Unsafe — это low-level операции:

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;  // Смещение в памяти
    
    static {
        try {
            // Получаем смещение поля value в памяти объекта
            valueOffset = unsafe.objectFieldOffset(
                AtomicInteger.class.getDeclaredField("value")
            );
        } catch (Exception ex) { throw new Error(ex); }
    }
    
    private volatile int value;  // !! VOLATILE !!
    
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            // CAS операция на уровне CPU
            if (compareAndSet(current, next))
                return next;
        }
    }
    
    public final boolean compareAndSet(int expect, int update) {
        // Прямой вызов CPU инструкции (CAS - Compare And Swap)
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

Механизм CAS в реальной жизни

Как это работает с многопоточностью:

// Сценарий: несколько потоков увеличивают счётчик
AtomicInteger counter = new AtomicInteger(0);

// Thread 1                          // Thread 2
current = counter.get();  // 0       current = counter.get();  // 0
next = 0 + 1;                       next = 0 + 1;
counter.compareAndSet(0, 1); // OK   counter.compareAndSet(0, 1); // FAIL!
                                     // Потому что значение уже 1
                                     // Попробуем снова
                                     current = counter.get();  // 1
                                     next = 1 + 1;
                                     counter.compareAndSet(1, 2); // OK

// Результат: counter = 2 (оба потока выполнены корректно)

Процессорные инструкции (x86/x64)

На уровне CPU используются инструкции типа CMPXCHG:

; Pseudocode процессорной инструкции CMPXCHG
CMPXCHG destination, source
; Если (destination == accumulator) {
;     destination = source
;     ZF = 1  (операция успешна)
; } else {
;     accumulator = destination
;     ZF = 0  (операция неудачна)
; }

; В Java это преобразуется в:
if (memory[valueOffset] == expectedValue) {
    memory[valueOffset] = newValue;
    return true;
} else {
    return false;
}

Сравнение: Synchronized vs Atomic

Synchronized (традиционный подход):

// ❌ С блокировкой (может быть slow)
public synchronized void increment() {
    value++;  // Заблокирован весь метод!
}

// Процесс:
// 1. Thread 1 захватывает lock
// 2. Thread 2 ждёт (блокируется)
// 3. Thread 1 выполняет и освобождает lock
// 4. Thread 2 захватывает lock и выполняет
// = Серийное выполнение (неэффективно при контентуре)

Atomic (lock-free подход):

// ✅ Без блокировки (быстрее)
AtomicInteger counter = new AtomicInteger();
int increment() {
    for (;;) {
        int current = counter.get();
        int next = current + 1;
        if (counter.compareAndSet(current, next))
            return next;
    }
}

// Процесс:
// 1. Thread 1 пытается CAS: текущее=0, новое=1. Успех!
// 2. Thread 2 пытается CAS: текущее=0, новое=1. Неудача! (уже 1)
// 3. Thread 2 пробует снова: текущее=1, новое=2. Успех!
// = Параллельное выполнение без блокировок!

Volatile флаг

Volatile в Atomic классах критичен:

public class AtomicInteger {
    private volatile int value;  // ВАЖНО: volatile!
}

// Почему volatile?
// 1. Гарантирует видимость изменений между потоками
// 2. Запрещает оптимизацию (переупорядочение операций)
// 3. Работает с memory barriers

// Без volatile это может произойти:
int value = 0;  // Без volatile

// Thread 1                   // Thread 2
value = 1;                  // Может не увидеть изменение!
print(value);               // Может вернуть 0!

Типы Atomic классов

// ✅ Скалярные типы (примитивы)
AtomicInteger       // int
AtomicLong          // long
AtomicBoolean       // boolean
AtomicReference<T>  // Object reference

// ✅ Array версии (атомарные операции над элементами массива)
AtomicIntegerArray
AtomicLongArray
AtomicReferenceArray<T>

// ✅ Field Updater версии (для обновления полей в классе)
AtomicIntegerFieldUpdater<T>
AtomicLongFieldUpdater<T>
AtomicReferenceFieldUpdater<T, V>

// Пример: обновляем field в existing классе без synchronized
public class Counter {
    private volatile int count = 0;
    
    private static final AtomicIntegerFieldUpdater<Counter> updater =
        AtomicIntegerFieldUpdater.newUpdater(Counter.class, "count");
    
    public void increment() {
        updater.incrementAndGet(this);
    }
}

Практический пример: Counter без synchronized

public class LockFreeCounter {
    private AtomicLong counter = new AtomicLong(0);
    
    public void increment() {
        counter.incrementAndGet();
    }
    
    public long getCount() {
        return counter.get();
    }
}

// Использование с потоками:
public static void main(String[] args) throws InterruptedException {
    LockFreeCounter counter = new LockFreeCounter();
    
    // 100 потоков, каждый увеличивает 1000 раз
    ExecutorService executor = Executors.newFixedThreadPool(100);
    for (int i = 0; i < 100; i++) {
        executor.submit(() -> {
            for (int j = 0; j < 1000; j++) {
                counter.increment();
            }
        });
    }
    
    executor.shutdown();
    executor.awaitTermination(10, TimeUnit.SECONDS);
    
    System.out.println("Final count: " + counter.getCount()); // 100000
}

ABA проблема

Есть тонкость, которую нужно знать:

// ABA проблема - когда значение меняется A -> B -> A
AtomicInteger value = new AtomicInteger(1);

// Thread 1              // Thread 2              // Thread 3
int current = 1;         // current = 1
Thread.sleep(1000);      value.set(2);           // Меняет на 2
                         value.set(1);           // Меняет обратно на 1
value.compareAndSet(1,5); // Успех! Но это неправильно!
                          // Значение поменялось два раза

Решение: AtomicStampedReference

// ✅ С версионированием (stamp) - защита от ABA
AtomicStampedReference<String> ref = 
    new AtomicStampedReference<>("initial", 0);

// Обновляем с проверкой версии
int[] stampHolder = new int[1];
String current = ref.get(stampHolder);
int stamp = stampHolder[0];

boolean success = ref.compareAndSet(
    current, "updated",
    stamp, stamp + 1  // Увеличиваем версию
);
// Если между get и compareAndSet значение поменялось,
// compareAndSet вернёт false

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

Benchmark: Atomic vs Synchronized vs Volatile

// ❌ Synchronized - медленно при много потоков
public synchronized void increment() {
    value++;
}

// ✅ Atomic - быстро, lock-free
AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

// Результаты на 4 ядрах:
// 1 thread:      synchronized = 2ns, atomic = 2ns, volatile = 8ns
// 4 threads:     synchronized = 25ns, atomic = 3ns, volatile = 12ns
// 16 threads:    synchronized = 100ns, atomic = 4ns, volatile = 20ns

// На 16 потоках Atomic в 25x раз быстрее!

Итоговая таблица

Практические выводы

✅ CAS (Compare-And-Swap) — основа всех Atomic классов ✅ Unsafe класс — предоставляет низкоуровневый доступ к памяти ✅ Volatile — гарантирует видимость изменений ✅ Lock-free — нет блокировок, высокая масштабируемость ⚠️ ABA проблема — для критичных сценариев используй AtomicStampedReference ✅ Когда использовать: счётчики, флаги, простые состояния в многопоточных системах

Ответ на интервью: "Atomic классы построены на CAS операции (Compare-And-Swap), которая выполняется атомарно на уровне процессора без блокировок. Внутри используется Unsafe класс, который предоставляет прямой доступ к памяти, и volatile флаг, который гарантирует видимость изменений между потоками. Это позволяет реализовать lock-free программирование с высокой производительностью на многоядерных системах."