Как установить зависимости между очередями?

Установка зависимостей между очередями в Grand Central Dispatch (GCD)

Установка зависимостей между очередями — это важный механизм синхронизации задач в параллельном программировании. В iOS/macOS разработке для этого используются несколько подходов, в зависимости от используемых API: Grand Central Dispatch (GCD) или OperationQueue.

Основные подходы

1. Использование DispatchGroup

DispatchGroup позволяет группировать задачи и отслеживать их завершение. Это фундаментальный инструмент для установки зависимостей "задача B должна ждать завершения задачи A".

let group = DispatchGroup()
let queue = DispatchQueue.global(qos: .userInitiated)

// Задача A
group.enter()
queue.async {
    defer { group.leave() }
    // Длительная операция A
    print("Task A completed")
}

// Задача B ждет завершения A
group.notify(queue: .main) {
    // Выполнится только после завершения всех enter/leave
    print("All tasks completed, updating UI")
}

// Или явное ожидание
queue.async {
    group.wait() // Блокирует текущий поток до завершения группы
    print("Task B starting after A")
}

2. DispatchSemaphore для ограничения доступа

Семафоры полезны для контроля доступа к общим ресурсам и установки порядка выполнения.

let semaphore = DispatchSemaphore(value: 0)
let queue = DispatchQueue.global()

queue.async {
    // Длительная операция
    semaphore.signal() // Увеличиваем счетчик
}

queue.async {
    semaphore.wait() // Ждем, пока счетчик не станет > 0
    // Выполнится только после signal()
}

3. OperationQueue и Operation Dependencies

Наиболее мощный и рекомендуемый подход для сложных зависимостей — использование OperationQueue и классов Operation.

// Создаем операции
let operationA = BlockOperation {
    print("Operation A executing")
}

let operationB = BlockOperation {
    print("Operation B executing")
}

let operationC = BlockOperation {
    print("Operation C executing")
}

// Устанавливаем зависимости: B → A, C → B
operationB.addDependency(operationA)
operationC.addDependency(operationB)

// Создаем очередь
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 2

// Добавляем операции
operationQueue.addOperations([operationA, operationB, operationC], waitUntilFinished: false)

// Результат: A → B → C (даже при параллельной очереди)

Продвинутые техники

Комбинирование DispatchGroup с барьерными задачами

Для установки зависимостей в конкретных очередях (особенно в concurrent очередях) используйте барьерные задачи:

let concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

concurrentQueue.async {
    print("Task 1 - может выполняться параллельно")
}

concurrentQueue.async(flags: .barrier) {
    print("Barrier task - выполнится после всех предыдущих")
}

concurrentQueue.async {
    print("Task 2 - выполнится только после barrier")
}

Последовательные очереди как простейшая зависимость

Самая простая форма зависимости — использование serial queue:

let serialQueue = DispatchQueue(label: "com.example.serial")

serialQueue.async {
    print("Task 1")
}

serialQueue.async {
    print("Task 2 - гарантированно после Task 1")
}

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

1. Выбор инструмента:

   • Для простых зависимостей: DispatchGroup или serial queue
   • Для сложных графов зависимостей: OperationQueue с addDependency
   • Для синхронизации доступа к ресурсам: DispatchSemaphore

2. Избегание deadlock:

   // ОПАСНО: deadlock на serial queue
   serialQueue.async {
       serialQueue.sync { // Deadlock!
           print("This will never execute")
       }
   }
   

3. Качество обслуживания (QoS): Устанавливайте соответствующий QoS для зависимостей, чтобы система правильно расставляла приоритеты:

   let highPriorityQueue = DispatchQueue.global(qos: .userInitiated)
   let lowPriorityQueue = DispatchQueue.global(qos: .background)
   

4. Отмена операций: Только OperationQueue предоставляет встроенную поддержку отмены зависимых операций:

   operationQueue.cancelAllOperations() // Отменяет все операции с учетом зависимостей
   

Пример реального использования

class DataProcessor {
    private let processingQueue = OperationQueue()
    
    func processData() {
        let downloadOp = BlockOperation { /* Загрузка данных */ }
        let parseOp = BlockOperation { /* Парсинг данных */ }
        let saveOp = BlockOperation { /* Сохранение в БД */ }
        let uiUpdateOp = BlockOperation { /* Обновление UI */ }
        
        // Настраиваем зависимости
        parseOp.addDependency(downloadOp)
        saveOp.addDependency(parseOp)
        uiUpdateOp.addDependency(saveOp)
        
        // UI обновление на главном потоке
        uiUpdateOp.queuePriority = .high
        uiUpdateOp.completionBlock = {
            DispatchQueue.main.async {
                // Финальное обновление UI
            }
        }
        
        processingQueue.addOperations(
            [downloadOp, parseOp, saveOp, uiUpdateOp], 
            waitUntilFinished: false
        )
    }
}

Правильная установка зависимостей между очередями критически важна для:

• Предотвращения race conditions
• Обеспечения предсказуемого порядка выполнения
• Оптимизации использования ресурсов
• Создания отзывчивого интерфейса

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