Можно ли в GCD дождаться выполнения нескольких методов и выполнить дальнейшие действия?

Можно ли в GCD дождаться выполнения нескольких методов?

Да, в Grand Central Dispatch (GCD) можно дождаться выполнения нескольких методов или задач перед выполнением дальнейших действий. GCD предоставляет несколько механизмов для синхронизации и группировки асинхронных операций. Основные подходы включают использование диспетчерских групп (DispatchGroup), барьеров (Dispatch Barrier), семафоров (DispatchSemaphore) и последовательностей (DispatchWorkItem) с зависимостями.

---

Основные механизмы синхронизации в GCD

1. DispatchGroup — диспетчерская группа

Это наиболее распространённый и удобный способ ожидания завершения нескольких асинхронных задач. Группа позволяет отслеживать выполнение набора задач и уведомить, когда все они завершены.

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

import Foundation

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

// Задача 1
group.enter()
queue.async {
    defer { group.leave() }
    // Выполнение асинхронной операции, например, сетевого запроса
    sleep(2)
    print("Задача 1 завершена")
}

// Задача 2
group.enter()
queue.async {
    defer { group.leave() }
    sleep(1)
    print("Задача 2 завершена")
}

// Ожидание завершения всех задач в группе
group.notify(queue: .main) {
    // Этот блок выполнится на главной очереди после всех задач
    print("Все задачи завершены. Продолжаем работу...")
    // Дальнейшие действия
}

// Альтернативный вариант: синхронное ожидание (блокирует текущий поток)
// group.wait() // Не рекомендуется на главной очереди

Ключевые моменты:

• enter() и leave() должны быть сбалансированы.
• notify(queue:) выполняет блок асинхронно по завершении группы.
• wait() блокирует текущий поток до завершения группы (опасно на главной очереди).

2. DispatchSemaphore — семафоры

Семафоры позволяют контролировать доступ к ресурсам или синхронизировать выполнение задач. Для ожидания нескольких методов можно использовать семафор со счётчиком.

Пример:

let semaphore = DispatchSemaphore(value: 0)
let concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

concurrentQueue.async {
    sleep(3)
    print("Метод A выполнен")
    semaphore.signal()
}

concurrentQueue.async {
    sleep(1)
    print("Метод B выполнен")
    semaphore.signal()
}

// Ожидаем завершения обеих задач
DispatchQueue.global().async {
    semaphore.wait() // Ждём первую задачу
    semaphore.wait() // Ждём вторую задачу
    print("Обе задачи завершены")
}

Важно: Не используйте wait() на главной очереди, чтобы не блокировать UI.

3. Dispatch Barrier — барьеры

Барьеры применяются в concurrent очередях для создания точки синхронизации. Задача с барьером выполнится только после завершения всех ранее поставленных задач.

Пример:

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

barrierQueue.async {
    print("Задача 1 началась")
    sleep(2)
}

barrierQueue.async {
    print("Задача 2 началась")
    sleep(1)
}

// Барьерная задача — выполнится после всех предыдущих
barrierQueue.async(flags: .barrier) {
    print("Барьер: все предыдущие задачи завершены")
}

barrierQueue.async {
    print("Задача после барьера")
}

4. Зависимости между DispatchWorkItem

Можно создавать зависимости между задачами через DispatchWorkItem, хотя этот подход менее распространён.

let workItem1 = DispatchWorkItem {
    print("WorkItem 1 выполнен")
}

let workItem2 = DispatchWorkItem {
    print("WorkItem 2 выполнен")
}

let workItemFinal = DispatchWorkItem {
    print("Все предварительные задачи завершены")
}

// Устанавливаем зависимости
workItemFinal.addDependency(workItem1)
workItemFinal.addDependency(workItem2)

let queue = DispatchQueue.global()
queue.async(execute: workItem1)
queue.async(execute: workItem2)
queue.async(execute: workItemFinal)

---

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

1. Для большинства сценариев используйте DispatchGroup — это самый читаемый и безопасный способ.
2. Избегайте блокировок на главной очереди — никогда не вызывайте group.wait() или semaphore.wait() на главном потоке, чтобы не заморозить интерфейс.
3. Учитывайте типы очередей:
   • Concurrent очереди (attributes: .concurrent) позволяют задачам выполняться параллельно.
   • Serial очереди выполняют задачи последовательно, что также может решить проблему синхронизации.
4. Обрабатывайте ошибки — в асинхронных операциях используйте defer для гарантированного вызова group.leave().
5. Альтернативы GCD — для сложных сценариев рассмотрите OperationQueue с зависимостями между операциями или современные подходы с async/await (доступно с iOS 13).

Вывод

GCD предоставляет богатый набор инструментов для синхронизации асинхронных задач. Выбор конкретного механизма зависит от контекста: DispatchGroup идеален для ожидания группы независимых операций, семафоры подходят для более сложной синхронизации, барьеры эффективны в concurrent очередях. Правильное использование этих инструментов позволяет эффективно управлять многозадачностью в iOS-приложениях.