Как синхронизировать данные между потоками (контекстом) в iOS?

Для синхронизации можно использовать следующие механизмы:

1. NSLock: Примитивный блокирующий мьютекс.

   let lock = NSLock()
   
   func doSomething() {
       lock.lock()
       // Критическая секция кода
       lock.unlock()
   }
   

2. NSRecursiveLock: Позволяет одному потоку многократно захватывать блокировку без дедлока.

   let recursiveLock = NSRecursiveLock()
   
   func recursiveFunction(level: Int) {
       recursiveLock.lock()
       if level < 3 {
           recursiveFunction(level: level + 1)
       }
       recursiveLock.unlock()
   }
   

3. NSCondition: Позволяет потокам ждать определенного условия, прежде чем продолжить выполнение.

   let condition = NSCondition()
   var dataAvailable = false
   
   func producer() {
       condition.lock()
       // Производство данных
       dataAvailable = true
       condition.signal() // Сигнализировать ожидающим потокам
       condition.unlock()
   }
   
   func consumer() {
       condition.lock()
       while !dataAvailable {
           condition.wait() // Ждать, пока условие не выполнится
       }
       // Обработка данных
       dataAvailable = false
       condition.unlock()
   }
   

4. NSConditionLock: Мьютекс, который может быть захвачен только при выполнении определенного условия-значения.

   let conditionLock = NSConditionLock(condition: 0)
   let DATA_READY = 1
   
   func producer() {
       conditionLock.lock(when: 0) // Захватить при условии 0
       // Производство данных
       conditionLock.unlock(withCondition: DATA_READY) // Снять блокировку и установить условие DATA_READY
   }
   
   func consumer() {
       conditionLock.lock(when: DATA_READY) // Захватить при условии DATA_READY
       // Обработка данных
       conditionLock.unlock(withCondition: 0) // Снять блокировку и установить условие 0
   }
   

5. Dispatch Queues (GCD): Использование последовательных dispath-очередей для доступа к общим ресурсам.

   let serialQueue = DispatchQueue(label: "com.yourapp.serialQueue")
   var sharedResource = 0
   
   func updateResource() {
       serialQueue.async {
           // Доступ к sharedResource только из этой очереди
           sharedResource += 1
       }
   }
   

6. NSOperationQueue: Позволяет контролировать зависимости и приоритеты операций.

   let operationQueue = OperationQueue()
   var sharedOperationResource = 0
   
   let operation1 = BlockOperation {
       // Доступ к sharedOperationResource
       sharedOperationResource += 1
   }
   
   operationQueue.addOperation(operation1)
   

7. Actors (Swift 5.5+): Обеспечивают изоляцию состояния, предотвращая одновременный доступ из разных контекстов.

   actor Counter {
       private var count = 0
   
       func increment() {
           count += 1
       }
   
       func getCount() -> Int {
           return count
       }
   }
   
   let counter = Counter()
   
   Task {
       await counter.increment()
       let currentCount = await counter.getCount()
       print(currentCount)
   }
   

8. Core Data Contexts: Для синхронизации data contexts можно использовать hierarchical contexts (родитель-потомок) или mergeChanges(fromContextDidSaveNotification:).

   // Пример с иерархией (родитель - фоновый, потомок - UI)
   let privateMoc = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
   privateMoc.persistentStoreCoordinator = persistentStoreCoordinator
   
   let mainMoc = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
   mainMoc.parent = privateMoc
   
   // Пример с mergeChanges
   NotificationCenter.default.addObserver(self,
                                          selector: #selector(contextDidSave(_:)),
                                          name: .NSManagedObjectContextDidSave,
                                          object: nil)
   
   @objc func contextDidSave(_ notification: Notification) {
       guard let savingContext = notification.object as? NSManagedObjectContext else { return }
   
       if savingContext != mainMoc { // Если сохранение произошло не в основном контексте
           mainMoc.perform {
               mainMoc.mergeChanges(fromContextDidSave: notification)
           }
       }
   }
   

9. Atomic operations: Использование атомарных примитивов (например, из os/lock.h) для простых операций.

Выбор метода зависит от сложности задачи, типа данных и требуемой производительности. Actors и GCD являются предпочтительными современными подходами.