Что может гарантировать Атомарность?

Атомарность в программировании: гарантии и ограничения

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

Что гарантирует атомарность?

Атомарность гарантирует следующее:

1. Целостность примитивных операций с простыми типами данных

   • Чтение и запись примитивных типов (Int, Bool, Float, указателей) выполняются за одну машинную инструкцию
   • Гарантируется, что другая нить не увидит промежуточное состояние

   // Пример: атомарная запись Bool (в большинстве архитектур)
   var isCompleted: Bool = false
   // Запись значения происходит атомарно на аппаратном уровне
   

2. Отсутствие состояния гонки данных для отдельных операций с примитивами

   • Когда поток записывает значение, другой поток увидит либо старое, либо новое значение, но не "битый" результат

3. Корректность работы с атомарными примитивами языка и фреймворков

   // Использование атомарных операций из stdlib
   import Darwin
   
   var counter: Int32 = 0
   // Атомарная инкрементация
   OSAtomicIncrement32(&counter)
   

Что атомарность НЕ гарантирует?

Важно понимать фундаментальные ограничения атомарности:

1. Не гарантирует потокобезопасность составных операций

   // ОПАСНЫЙ ПРИМЕР: атомарность отдельных операций ≠ потокобезопасность
   class BankAccount {
       var balance: Int = 1000 // Чтение/запись Int атомарны
       
       func transfer(amount: Int, to account: BankAccount) {
           // Каждая операция атомарна, но вся последовательность — НЕТ
           self.balance -= amount  // (1) атомарно
           account.balance += amount // (2) атомарно
           // Между (1) и (2) состояние системы некорректно!
       }
   }
   

2. Не заменяет механизмы синхронизации для сложных структур данных

   // Проблема даже с атомарным Bool
   var isProcessing: Bool = false
   
   func startProcessing() {
       if !isProcessing {          // (1) атомарное чтение
           isProcessing = true     // (2) атомарная запись
           // Но между (1) и (2) другой поток мог изменить значение!
           performWork()
       }
   }
   

3. Не обеспечивает видимость изменений между потоками без барьеров памяти

   • На современных процессорах с out-of-order исполнением и многоуровневыми кэшами нужны барьеры памяти (memory barriers)

Практическое применение в iOS

1. Атомарные свойства в Objective-C

   // atomic — гарантирует атомарность геттера/сеттера
   @property (atomic, strong) NSArray *items;
   // Но это НЕ делает работу с массивом потокобезопасной!
   

2. Атомарные операции в Swift через Atomics

   import Atomics
   
   // Использование ManagedAtomic для атомарных операций
   let atomicCounter = ManagedAtomic<Int>(0)
   
   // Атомарные операции
   let oldValue = atomicCounter.load(ordering: .acquiring)
   atomicCounter.store(42, ordering: .releasing)
   let swapped = atomicCounter.compareExchange(
       expected: 0, 
       desired: 1, 
       ordering: .sequentiallyConsistent
   )
   

3. Паттерны использования атомарности:

   • Флаги состояния (atomic flags для lightweight условий)
   • Счетчики ссылок (подсчет активных пользователей ресурса)
   • One-time инициализация (Double-Checked Locking с атомарными флагами)

Ключевые выводы

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

1. Мьютексы и семафоры для защиты критических секций
2. Очереди GCD с правильными атрибутами QoS
3. Акторы (Swift Concurrency) для изоляции состояния
4. Барьеры памяти для обеспечения порядка операций

// Правильный подход: использование DispatchQueue для синхронизации
class ThreadSafeCounter {
    private var value: Int = 0
    private let queue = DispatchQueue(label: "com.example.counter", attributes: .concurrent)
    
    func increment() {
        queue.async(flags: .barrier) {
            self.value += 1
        }
    }
    
    func currentValue() -> Int {
        queue.sync {
            return self.value
        }
    }
}

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