В чем разница между Dispatch barrier и semaphore?

Разница между Dispatch Barrier и Semaphore в GCD

В iOS разработке для управления многопоточностью часто используются механизмы Grand Central Dispatch (GCD), и два важных из них — Dispatch Barrier и Semaphore. Хотя оба служат для синхронизации потоков, они решают принципиально разные задачи и имеют различную семантику.

🛡️ Dispatch Barrier (Барьерная задача)

Dispatch Barrier — это механизм для работы с конкурентными очередями (DispatchQueue.concurrent), который позволяет выполнить задачу эксклюзивно, пока все остальные задачи в очереди ожидают.

Ключевые особенности:

• Используется только на созданных вручную concurrent очередях (не работает на глобальных очередях .global() или последовательных очередях)
• Задачи до barrier выполняются параллельно
• Barrier задача выполняется одна, блокируя очередь
• После barrier задачи снова выполняются параллельно

Типичный use case:

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

class ThreadSafeDictionary<Key: Hashable, Value> {
    private var dictionary = [Key: Value]()
    private let concurrentQueue = DispatchQueue(
        label: "com.example.dictionary",
        attributes: .concurrent
    )
    
    func get(_ key: Key) -> Value? {
        return concurrentQueue.sync {
            dictionary[key]
        }
    }
    
    func set(_ key: Key, _ value: Value) {
        // Барьер гарантирует эксклюзивный доступ при записи
        concurrentQueue.async(flags: .barrier) {
            self.dictionary[key] = value
        }
    }
}

🔒 Semaphore (Семафор)

Semaphore — это классический механизм синхронизации, который контролирует доступ к ресурсу через счетчик. В GCD реализован через DispatchSemaphore.

Ключевые особенности:

• Имеет счетчик (value), определяющий сколько потоков могут одновременно получить доступ
• Методы wait() уменьшает счетчик, signal() увеличивает
• Если счетчик достигает 0, следующие потоки блокируются до вызова signal()
• Может использоваться в любых очередях и даже между разными очередями

Типичные use cases:

1. Ограничение количества одновременных операций
2. Ожидание завершения нескольких асинхронных задач
3. Синхронизация между разными очередями/потоками

// Пример: Ограничение до 3 одновременных сетевых запросов
class NetworkManager {
    private let semaphore = DispatchSemaphore(value: 3)
    
    func makeRequest(_ url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
        semaphore.wait()
        
        URLSession.shared.dataTask(with: url) { data, response, error in
            defer { self.semaphore.signal() }
            
            if let error = error {
                completion(.failure(error))
                return
            }
            completion(.success(data ?? Data()))
        }.resume()
    }
}

// Пример: Ожидание завершения нескольких асинхронных задач
func fetchMultipleResources(urls: [URL]) async throws -> [Data] {
    let semaphore = DispatchSemaphore(value: 0)
    var results = [Data?](repeating: nil, count: urls.count)
    var errors: [Error] = []
    
    for (index, url) in urls.enumerated() {
        URLSession.shared.dataTask(with: url) { data, _, error in
            if let error = error {
                errors.append(error)
            } else {
                results[index] = data
            }
            semaphore.signal()
        }.resume()
    }
    
    // Ждем завершения всех задач
    for _ in urls {
        semaphore.wait()
    }
    
    if !errors.isEmpty { throw errors.first! }
    return results.compactMap { $0 }
}

📊 Сравнительная таблица

🎯 Когда что использовать?

Используйте Dispatch Barrier когда:

• Работаете с собственной concurrent очередью
• Нужен паттерн "множественное чтение / эксклюзивная запись"
• Хотите оптимизировать производительность для конкретной структуры данных

Используйте Semaphore когда:

• Нужно ограничить количество одновременных операций (throttling)
• Требуется синхронизация между разными очередями
• Нужно дождаться завершения нескольких асинхронных задач
• Реализуете сложные сценарии межпоточного взаимодействия

⚠️ Важные предостережения

1. Semaphore требует аккуратности — несбалансированные wait()/signal() вызовы приведут к deadlock или непредсказуемому поведению
2. Barrier не для serial очередей — в последовательных очередях он бесполезен, так как задачи и так выполняются по одной
3. Избегайте длительных операций в барьерных задачах — это заблокирует всю concurrent очередь
4. В современных подходах рассмотрите async/await с actors в Swift как более безопасную альтернативу

Оба инструмента мощные, но требуют глубокого понимания многопоточности. Barrier — это специализированный инструмент для оптимизации доступа к данным в concurrent очередях, тогда как Semaphore — универсальный механизм синхронизации для сложных межпоточных сценариев. Выбор зависит от конкретной задачи и архитектуры вашего приложения.