Какие знаешь Atomic в Swift?

Atomic операции в Swift

В Swift отсутствуют готовые Atomic типы (такие как AtomicInteger в Java), как часть стандартной библиотеки. Однако проблема атомарности (обеспечение безопасного доступа к данным в многопоточной среде) решается с помощью различных механизмов синхронизации и низкоуровневых операций.

Основные подходы к обеспечению атомарности

1. Использование GCD и очередей

Самый распространённый способ — Grand Central Dispatch (GCD) и диспетчеризация задач на специальные очереди.

class AtomicCounter {
    private var counter = 0
    private let queue = DispatchQueue(label: "com.example.atomic.queue")
    
    func increment() {
        queue.sync {
            counter += 1
        }
    }
    
    func getValue() -> Int {
        return queue.sync { counter }
    }
}

• DispatchQueue.sync блокирует текущий поток до завершения операции.
• Для производительности можно использовать барьерные задачи (DispatchQueue.barrier) на concurrent-очереди.

2. NSLock и другие низкоуровневые мьютексы

Swift предоставляет несколько типов локов из Foundation:

import Foundation

class AtomicContainer<T> {
    private var value: T
    private let lock = NSLock()
    
    init(_ value: T) {
        self.value = value
    }
    
    func update(_ newValue: T) {
        lock.lock()
        value = newValue
        lock.unlock()
    }
    
    func read() -> T {
        lock.lock()
        let result = value
        lock.unlock()
        return result
    }
}

• NSLock — базовый мьютекс, но требует осторожности (deadlocks).
• NSRecursiveLock — позволяет повторное захватывание в одном потоке.
• NSConditionLock — lock с условиями ожидания.

3. Actor модель (Swift 5.5+)

Самый современный и безопасный подход — использование Actor. Это тип, который гарантирует изоляцию состояния.

actor AtomicActor {
    private var count = 0
    
    func increment() {
        count += 1
    }
    
    func getCount() -> Int {
        return count
    }
}

// Использование
let actor = AtomicActor()
Task {
    await actor.increment()
    let current = await actor.getCount()
}

• Actor автоматически предотвращает одновременный доступ к его свойствам.
• Доступ к актору возможен только через await в асинхронном контексте.

4. Атомарные операции через C-интерфейсы

В крайних случаях можно использовать низкоуровневые функции из C/Objective-C, например OSAtomic семейство (но многие теперь deprecated) или атомарные операции LLVM (через UnsafeAtomic в Swift 5.7+).

import SwiftAtomics

let atomicInt = ManagedAtomic<Int>(0)
atomicInt.wrappingIncrement(by: 1)
let current = atomicInt.load()

• SwiftAtomics (в Swift 5.7) предоставляет ManagedAtomic и UnsafeAtomic для атомарных операций (load, store, compareExchange).
• Это самый низкий уровень, обычно нужен для реализации высокопроизводительных структур данных.

5. Property Wrappers для атомарности

Можно создать property wrapper, чтобы упростить использование атомарных свойств.

@propertyWrapper
struct Atomic<T> {
    private var value: T
    private let lock = NSLock()
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
    
    var wrappedValue: T {
        get {
            lock.lock()
            defer { lock.unlock() }
            return value
        }
        set {
            lock.lock()
            value = set
            lock.unlock()
        }
    }
}

class Example {
    @Atomic var counter = 0
}

Ключевые моменты

• Swift не имеет built-in Atomic типов в отличие от некоторых языков.
• Actor — рекомендуемый способ для новых проектов (Swift 5.5+).
• GCD и locks — классические решения, но требуют ручного управления.
• SwiftAtomics — для низкоуровневых задач (производительность, CAS операции).
• Главная цель — предотвращение race conditions, data races и обеспечение thread safety.

Выбор механизма зависит от контекста: Actor для общего случая, SwiftAtomics для высокопроизводительных структур, GCD/locks для совместимости с legacy кодом или тонкого контроля.