Что такое атомарные типы?

Атомарные типы

Атомарные типы — это специальные классы из пакета java.util.concurrent.atomic, которые предоставляют потокобезопасные операции над переменными без использования явной синхронизации. Они основаны на аппаратных атомарных инструкциях процессора (compare-and-swap операции, CAS).

Основные атомарные классы

В Java есть несколько групп атомарных типов:

1. AtomicInteger, AtomicLong, AtomicBoolean

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();  // атомарное увеличение на 1
counter.getAndAdd(5);       // добавить 5 и вернуть старое значение
counter.compareAndSet(5, 10); // CAS операция

2. AtomicReference — для атомарных операций с объектами

AtomicReference<String> ref = new AtomicReference<>("initial");
ref.compareAndSet("initial", "updated");

3. AtomicIntegerArray, AtomicLongArray — для массивов

AtomicIntegerArray array = new AtomicIntegerArray(10);
array.incrementAndGet(0); // увеличить элемент с индексом 0

4. AtomicMarkableReference, AtomicStampedReference — версионированные ссылки

AtomicStampedReference<String> ref = new AtomicStampedReference<>("value", 0);
int[] stamp = new int[1];
String value = ref.get(stamp); // получить значение и версию

Как они работают

Атомарные операции реализуют на уровне процессора через CAS (Compare-And-Swap):

// Псевдокод того, что происходит внутри
public int incrementAndGet() {
  int current, next;
  do {
    current = value;       // прочитали текущее значение
    next = current + 1;    // вычислили новое
  } while (!compareAndSet(current, next)); // пока не удалось заменить атомарно
  return next;
}

Преимущества над synchronized

• Нет блокировок — используются аппаратные инструкции
• Лучше масштабируемость — в многопоточных приложениях нет contention
• Неблокирующие алгоритмы — можно писать lock-free структуры данных
• Более гибкие — поддерживают сложные операции (CAS)

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

Счётчик в многопоточной среде:

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

Lock-free очередь:

public class LockFreeStack<T> {
  private AtomicReference<Node<T>> head = new AtomicReference<>();
  
  private static class Node<T> {
    final T value;
    Node<T> next;
    Node(T value) { this.value = value; }
  }
  
  public void push(T value) {
    Node<T> newHead = new Node<>(value);
    Node<T> oldHead;
    do {
      oldHead = head.get();
      newHead.next = oldHead;
    } while (!head.compareAndSet(oldHead, newHead));
  }
}

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

• Счётчики, флаги в многопоточных приложениях
• Кэши, когда нужна потокобезопасная замена значения
• Lock-free алгоритмы и структуры данных
• Когда contention критичен для performance

Атомарные типы — мощный инструмент для параллельного программирования в Java, но требуют понимания их семантики.