Что такое atomics, какие бывают и как и когда их лучше использовать?go-49

Атомарные операции (atomics) — это низкоуровневые примитивы синхронизации, обеспечивающие безопасное изменение общих данных между горутинами без использования мьютексов.

Пакет sync/atomic

Go предоставляет атомарные операции через пакет sync/atomic:

Основные типы atomic:

1. int32, int64 - атомарные целые числа
2. uint32, uint64 - беззнаковые атомарные целые
3. uintptr - атомарные указатели
4. unsafe.Pointer - атомарные операции с указателями
5. Value - универсальный контейнер для любых значений (с Go 1.4)

Основные операции

1. Атомарное чтение и запись

var counter int64

// Атомарная запись
atomic.StoreInt64(&counter, 10)

// Атомарное чтение
val := atomic.LoadInt64(&counter)

2. Атомарное сложение

atomic.AddInt64(&counter, 1) // Инкремент
atomic.AddInt64(&counter, -1) // Декремент

3. Compare-and-Swap

old := atomic.LoadInt64(&counter)
new := old + 1
if !atomic.CompareAndSwapInt64(&counter, old, new) {
    // Кто-то успел изменить значение
}

4. Атомарный обмен

old := atomic.SwapInt64(&counter, 100) // Устанавливает новое и возвращает старое

sync/atomic.Value

Универсальный контейнер для атомарного хранения любых значений:

var config atomic.Value

// Сохранение
config.Store(Config{Timeout: 10})

// Загрузка
cfg := config.Load().(Config)

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

1. Счетчики и простые флаги
   Идеально для высоконагруженных счетчиков

2. Read-mostly данные
   Когда обновления редки, а чтения частые

3. Низкоуровневая синхронизация
   При реализации собственных примитивов синхронизации

4. Performance-critical участки
   Где мьютексы слишком медленные

Преимущества перед мьютексами

1. Высокая производительность
   Нет блокировок, только CPU-атомарные инструкции

2. Отсутствие deadlock
   Нет проблем с вложенными блокировками

3. Меньшие накладные расходы
   Особенно заметно в высококонкурентных сценариях

Ограничения и опасности

1. Только простые типы
   Не подходит для сложных структур данных

2. Нет защиты от гонок за данными
   Только для отдельных переменных

3. Сложность отладки
   Тонкие ошибки сложнее обнаружить

4. ABA проблема
   В сложных CAS-сценариях

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

1. Атомарный счетчик

type AtomicCounter struct {
    value int64
}

func (c *AtomicCounter) Increment() {
    atomic.AddInt64(&c.value, 1)
}

func (c *AtomicCounter) Value() int64 {
    return atomic.LoadInt64(&c.value)
}

2. Атомарный флаг

var isRunning uint32

func Start() {
    if atomic.CompareAndSwapUint32(&isRunning, 0, 1) {
        go worker()
    }
}

3. Lock-free структуры данных

type Stack struct {
    head unsafe.Pointer
}

func (s *Stack) Push(value interface{}) {
    newHead := &Element{value: value}
    for {
        oldHead := atomic.LoadPointer(&s.head)
        newHead.next = oldHead
        if atomic.CompareAndSwapPointer(&s.head, oldHead, unsafe.Pointer(newHead)) {
            return
        }
    }
}

Сравнение с другими методами

Метод	Простота	Производительность	Безопасность	Применимость
Atomics	Средняя	Очень высокая	Средняя	Простые счетчики/флаги
Мьютексы	Высокая	Средняя	Высокая	Любые данные
Каналы	Высокая	Низкая	Высокая	Коммуникация

Резюмируем

1. Что такое atomics
   Низкоуровневые операции для безопасного изменения переменных между горутинами

2. Основные типы
   int32/64, uint32/64, uintptr, unsafe.Pointer, Value

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

   • Простые счетчики и флаги
   • Read-mostly сценарии
   • Критичные к производительности участки
   • Реализация lock-free алгоритмов

4. Когда не использовать

   • Для сложных структур данных
   • Когда важна простота кода
   • При частых обновлениях разных переменных

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