Что такое Атомарная запись?

Что такое атомарная запись?

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

В контексте iOS-разработки атомарность критически важна для работы с разделяемыми ресурсами (например, общими переменными, файлами, данными в памяти), чтобы избежать состояний гонки (race conditions), повреждения данных или неконсистентного состояния приложения.

Ключевые свойства атомарной записи:

1. Неделимость — операция не может быть прервана другими потоками.
2. Изоляция — промежуточные результаты записи не видны другим потокам.
3. Атомарность на уровне аппаратуры или системы — обеспечивается либо процессорными инструкциями (например, CAS — Compare-And-Swap), либо механизмами ОС (например, мьютексы).

Пример проблемы без атомарности

Представьте счётчик, который инкрементируют несколько потоков:

class NonAtomicCounter {
    private var value: Int = 0
    
    func increment() {
        let current = value
        // Поток может быть прерван здесь другим потоком!
        value = current + 1
    }
}

Если два потока одновременно прочитают value (например, 0), оба увеличат его до 1, и конечное значение станет 1 вместо ожидаемых 2. Это состояние гонки.

Реализация атомарной записи в iOS

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

В Swift можно использовать Atomic-обёртки или свойства с модификатором atomic в Objective-C (хотя это не всегда гарантирует потокобезопасность на уровне логики). Пример с использованием OSAtomic или современных std::atomic (в C++):

import Foundation

class AtomicCounter {
    private let queue = DispatchQueue(label: "atomic.queue", attributes: .concurrent)
    private var _value: Int = 0
    
    var value: Int {
        queue.sync { _value }
    }
    
    func increment() {
        queue.async(flags: .barrier) {
            self._value += 1
        }
    }
}

2. Использование барьерных задач в DispatchQueue

Барьер (barrier) гарантирует, что задача выполнится атомарно относительно других задач в параллельной очереди:

class AtomicDataManager {
    private let concurrentQueue = DispatchQueue(label: "com.example.atomic", attributes: .concurrent)
    private var data: [String: Any] = [:]
    
    func setValue(_ value: Any, forKey key: String) {
        concurrentQueue.async(flags: .barrier) {
            self.data[key] = value
        }
    }
    
    func value(forKey key: String) -> Any? {
        concurrentQueue.sync {
            data[key]
        }
    }
}

3. Использование мьютексов и семафоров

Например, с помощью NSLock или pthread_mutex_t:

class AtomicWithLock {
    private var value: Int = 0
    private let lock = NSLock()
    
    func updateValue(newValue: Int) {
        lock.lock()
        defer { lock.unlock() }
        value = newValue  // Атомарная запись
    }
}

4. Атомарные операции в Swift через Actor (с Swift 5.5)

Actors предоставляют встроенную механику атомарности за счёт изоляции состояния:

actor AtomicActor {
    private var counter: Int = 0
    
    func increment() {
        counter += 1  // Автоматически атомарно внутри actor
    }
    
    func getValue() -> Int {
        counter
    }
}

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

Почему атомарная запись важна в iOS?

• Многопоточность: GCD, OperationQueue, async/await — без атомарности данные легко повреждаются.
• Кэширование и состояние приложения: Например, атомарное сохранение настроек пользователя или кэшированных изображений.
• Работа с файловой системой: Запись в файл должна быть атомарной, чтобы избежать частично записанных данных (используют временные файлы с последующим перемещением).
• Синхронизация данных: В Core Data или Realm атомарные транзакции обеспечивают целостность БД.

Ограничения и нюансы

• Атомарность ≠ потокобезопасность: Даже атомарная запись отдельной переменной не гарантирует корректность сложных составных операций (например, проверка условия с последующей записью). Для этого нужны более высокоуровневые синхронизации.
• Производительность: Атомарные операции часто медленнее из-за блокировок или использования барьеров.
• Выбор инструмента: В Swift стандартной библиотечной атомарности нет, поэтому используют DispatchQueue, locks или Actors.

Заключение

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