Когда может пригодиться барьерная операция?

Барьерные операции в многопоточных системах

Барьерная операция (barrier) — это мощный механизм синхронизации в многопоточном программировании, который гарантирует, что все задачи, предшествующие барьеру, завершатся до того, как следующие задачи смогут начать выполнение. Это особенно критично в контексте iOS разработки, где мы часто работаем с параллельными потоками, Grand Central Dispatch (GCD) и операциями.

Основные ситуации применения барьерных операций

1. Синхронизация чтения и записи в общих ресурсах Это самый классический пример. При работе с общим ресурсом (например, массивом, словарем или файлом) в многопоточной среде, чтобы избежать состояния гонки (race condition), операции записи должны быть атомарными относительно операций чтения.

   private let concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)
   private var sharedDictionary: [String: Int] = [:]
   
   func safeWrite(key: String, value: Int) {
       // Барьерная задача гарантирует, что во время ее выполнения НЕТ других читающих или пишущих задач
       concurrentQueue.async(flags: .barrier) {
           self.sharedDictionary[key] = value
       }
   }
   
   func safeRead(key: String) -> Int? {
       // Обычные читающие задачи могут выполняться параллельно друг с другом
       var result: Int?
       concurrentQueue.sync {
           result = self.sharedDictionary[key]
       }
       return result
   }
   

   Здесь async(flags: .barrier) для записи делает эту операцию эксклюзивной. Все предыдущие sync или async задачи на этой queue будут завершены, и никакие новые задачи не запустятся, пока барьерная задача не закончит запись.

2. Обновление UI после завершения группы параллельных вычислений В iOS часто требуется выполнить несколько независимых сетевых запросов или тяжелых вычислений параллельно, и только после успешного завершения всех обновить интерфейс пользователя.

   func fetchMultipleDataAndUpdateUI() {
       let barrierQueue = DispatchQueue(label: "com.example.barrier")
   
       // Параллельные задачи загрузки
       for url in resourceURLs {
           DispatchQueue.global().async {
               let data = self.fetchData(from: url)
               barrierQueue.async {
                   self.process(data)
               }
           }
       }
   
       // Барьерная задача - обновление UI запустится строго ПОСЛЕ всех process(data)
       barrierQueue.async(flags: .barrier) {
           DispatchQueue.main.async {
               self.updateUI()
           }
       }
   }
   

3. Подготовка данных для следующей стадии pipeline обработки В сложных цепочках обработки данных (например, обработка изображения: декодирование → фильтрация → компрессия), барьер используется для гарантии, что все этапы предыдущей стадии завершены, перед началом следующей стадии, которая может зависеть от совокупного результата.

Ключевые особенности барьеров в GCD (DispatchQueue)

• Они работают только на concurrent queues (созданных с атрибутом .concurrent). На serial queues они не имеют смысла, так как задачи там уже выполняются строго последовательно.
• Барьерная задача не является просто блокирующей операцией (sync). Она позволяет другим задачам в queue выполняться параллельно до ее момента, но в момент ее исполнения очередь становится эффективно serial, обеспечивая эксклюзивный доступ.
• Это более эффективная альтернатива использованию мьютексов или семафоров для защиты ресурсов в многих сценариях, поскольку она минимизирует блокировки и позволяет максимально использовать параллелизм для операций чтения.

Практический пример из реального iOS приложения

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

class ImageCache {
    private let cache = NSCache<NSString, UIImage>()
    private let queue = DispatchQueue(label: "com.app.imageCache", attributes: .concurrent)

    func image(forKey key: String) -> UIImage? {
        // Множество потоков может одновременно читать
        return queue.sync {
            cache.object(forKey: key as NSString)
        }
    }

    func setImage(_ image: UIImage, forKey key: String) {
        // Запись — барьерная операция
        queue.async(flags: .barrier) {
            cache.setObject(image, forKey: key as NSString)
        }
    }
}

Итог: Барьерные операции — это фундаментальный инструмент для обеспечения корректности и целостности данных в многопоточных iOS приложениях, особенно при работе с общим состоянием (shared mutable state), когда необходимо сочетать высокую производительность параллельного чтения с безопасностью эксклюзивной записи. Их использование напрямую влияет на надежность приложения, предотвращая трудноуловимые ошибки, связанные с неопределенным порядком выполнения потоков.