Является ли словарь потокобезопасной коллекцией?

Потокобезопасность словаря (Dictionary) в iOS/macOS разработке

Нет, стандартные словари (Dictionary в Swift, NSDictionary/NSMutableDictionary в Objective-C) НЕ являются потокобезопасными коллекциями по умолчанию. Это один из фундаментальных аспектов многопоточной разработки, который важно понимать, чтобы избежать трудноуловимых ошибок.

Почему словари не потокобезопасны?

Стандартные реализации словарей оптимизированы для максимальной производительности в однопоточном контексте. При одновременном доступе из нескольких потоков возникают следующие риски:

1. Race conditions (состояние гонки) - когда результат операции зависит от порядка выполнения потоков
2. Data corruption (повреждение данных) - внутренняя структура словаря может быть нарушена
3. Crashes (аварийные завершения) - особенно при одновременной модификации
4. Unexpected behavior (непредсказуемое поведение) - значения могут "теряться" или читаться некорректно

Пример опасного кода

var sharedDictionary = [String: Int]()

// Поток 1
DispatchQueue.global().async {
    for i in 0..<1000 {
        sharedDictionary["key\(i)"] = i
    }
}

// Поток 2
DispatchQueue.global().async {
    for i in 0..<1000 {
        if let value = sharedDictionary["key\(i)"] {
            print(value) // Может сработать, а может и нет
        }
    }
}

Решения для потокобезопасной работы со словарями

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

Наиболее распространённый подход в iOS-разработке:

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

2. Использование NSLock или pthread_mutex

class MutexProtectedDictionary<Key: Hashable, Value> {
    private var dictionary = [Key: Value]()
    private var lock = NSLock()
    
    func update(with block: @escaping (inout [Key: Value]) -> Void) {
        lock.lock()
        defer { lock.unlock() }
        block(&dictionary)
    }
    
    func value(forKey key: Key) -> Value? {
        lock.lock()
        defer { lock.unlock() }
        return dictionary[key]
    }
}

3. Actor в Swift 5.5+

С появлением Swift Concurrency самый современный подход:

actor SafeDictionary<Key: Hashable, Value> {
    private var storage: [Key: Value] = [:]
    
    func set(_ value: Value, forKey key: Key) {
        storage[key] = value
    }
    
    func get(forKey key: Key) -> Value? {
        return storage[key]
    }
}

// Использование
let dictionary = SafeDictionary<String, Int>()

Task {
    await dictionary.set(42, forKey: "answer")
    let value = await dictionary.get(forKey: "answer")
}

4. NSCache для специфических случаев

NSCache автоматически управляет памятью и является потокобезопасным:

let cache = NSCache<NSString, NSNumber>()
cache.setObject(42 as NSNumber, forKey: "answer" as NSString)
let value = cache.object(forKey: "answer" as NSString)

Практические рекомендации

1. Чтение vs Запись: Если у вас частые чтения и редкие записи, используйте .concurrent очередь с барьерами для записи
2. Производительность: Самый быстрый вариант - pthread_mutex, но DispatchQueue более идиоматичен для Swift
3. Swift Concurrency: Для новых проектов предпочитайте actor - это наиболее безопасный и современный подход
4. Избегайте @synchronized: В Swift этот подход из Objective-C менее эффективен и не рекомендуется

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

• Стандартные словари не потокобезопасны - это осознанное решение для производительности
• Синхронизация - ответственность разработчика - вы должны обеспечить безопасный доступ
• Выбор подхода зависит от контекста - частоты операций, требований к производительности, версии iOS
• Тестируйте многопоточный код - используйте Thread Sanitizer в Xcode для обнаружения гонок данных

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