Какие знаешь способы реализации потокобезопасности для коллекций?

Потокобезопасность коллекций в iOS разработке

В многопоточной iOS-разработке обеспечение потокобезопасности для коллекций критически важно для предотвращения data races, инконсистентности данных и неожиданных крахов приложения. Вот основные подходы и их реализация.

1. Использование потокобезопасных классов из Foundation

Apple предоставляет несколько специализированных классов:

NSCache — потокобезопасный вариант для временного хранения объектов (например, изображений), автоматически удаляет элементы при недостатке памяти или давлении на память.

let cache = NSCache<NSString, UIImage>()
cache.setObject(image, forKey: "avatar")
let cachedImage = cache.object(forKey: "avatar")

NSLock и NSRecursiveLock — базовые механизмы для защиты операций:

class ThreadSafeArray<T> {
    private var array = [T]()
    private let lock = NSLock()
    
    func append(_ element: T) {
        lock.lock()
        array.append(element)
        lock.unlock()
    }
}

2. DispatchQueue с барьером для чтения/записи

Для Dictionary или собственных структур данных эффективно использовать DispatchQueue с барьером:

class ThreadSafeDictionary<Key: Hashable, Value> {
    private var dict = [Key: Value]()
    private let queue = DispatchQueue(label: "com.example.dict", attributes: .concurrent)
    
    func set(_ value: Value, forKey key: Key) {
        queue.async(flags: .barrier) {
            self.dict[key] = value
        }
    }
    
    func get(forKey key: Key) -> Value? {
        return queue.sync {
            return self.dict[key]
        }
    }
}

Барьерные операции гарантируют, что блок записи выполняется эксклюзивно, а чтение — конкурентно.

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

С внедрением Actors в Swift появилась нативная поддержка потокобезопасности:

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

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

Actor изолирует состояние и требует await для взаимодействия, автоматически предотвращая параллельный доступ.

4. @MainActor для UI-коллекций

Для коллекций, связанных с интерфейсом (например, источников данных для UITableView), применяется @MainActor:

@MainActor
class DataSource {
    private var items = [String]()
    
    func updateItems(newItems: [String]) {
        items = newItems
        // UI обновления безопасны
    }
}

5. Copy-on-write и value семантика

Для Swift Collections (Array, Dictionary) можно использовать value семантику с копированием:

var sharedArray = [Int]()
DispatchQueue.global().async {
    var localCopy = sharedArray // Copy-on-write
    localCopy.append(5)
    // Затем синхронизировать обратно через lock или queue
}

6. ConcurrentPerform и атомарные операции

Для высокопроизводительных вычислений с DispatchQueue.concurrentPerform:

var safeResults = [Int]()
let resultsLock = NSLock()

DispatchQueue.concurrentPerform(iterations: 100) { index in
    let result = index * 2
    resultsLock.lock()
    safeResults.append(result)
    resultsLock.unlock()
}

Критерии выбора подхода

• Производительность vs безопасность: Actor и DispatchQueue подходят для большинства случаев, NSLock — легковесный вариант.
• Сложность данных: Для nested структур лучше использовать RecursiveLock.
• Swift Concurrency: В новых проектах предпочтительно применять Actor и @MainActor.
• Уровень изоляции: Глобальные коллекции требуют строгой защиты, локальные — иногда могут обойтись копированием.

Правильный выбор зависит от контекста: частоты операций, объема данных и архитектуры приложения. Современный Swift все больше ориентируется на Actor модель как основной инструмент для потокобезопасности.