Как использовать DispatchGroup для синхронизации асинхронных задач в Swift?

Слушай, а вот эта штука — DispatchGroup — она же, блядь, как тот самый Герасим из рассказа, только для асинхронных задач, понимаешь? Немой, здоровый мужик, который стоит и считает: "Му-му... му-му...". Зашла задача в группу — он говорит "Му!" (это enter()), вышла — "Му!" (это leave()). И когда все "Му-му" закончились, он такой: "Ну всё, пиздуй дальше, я всех посчитал".

Вот смотри, как это выглядит в коде, блядь:

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

// Задача первая, сука
group.enter() // Герасим: "Му!"
queue.async {
    defer { group.leave() } // Автоматом скажет "Му!" на выходе, даже если всё пиздец

    Thread.sleep(forTimeInterval: 1)
    print("Первая хуйня сделана")
}

// Задача вторая, ёпта
group.enter() // "Му-му!"
queue.async {
    defer { group.leave() } // Опять "Му!"

    Thread.sleep(forTimeInterval: 2)
    print("Вторая хуйня тоже")
}

// И теперь, блядь, варианта два:
// Либо ждём, как лох, блокируя поток:
group.wait() // Стоим, бля, как вкопанные, пока все "Му-му" не закончатся
print("Всё, приехали (блокирующий вариант)")

// Либо по-умному, через notify:
group.notify(queue: .main) {
    // Это выполнится на главной очереди, когда все "Му-му" уйдут
    print("Всё, приплыли (неблокирующий вариант)")
    self.обновитьИнтерфейс()
}

print("А это выведется сразу, потому что мы не ждём, мы — хитрожопые")

А вот, блядь, где это реально пригождается, на практике:

1. Несколько сетевых запросов параллельно, сука:

func загрузитьВсёХуйню(completion: @escaping ([Data]) -> Void) {
    let group = DispatchGroup()
    var результаты: [Data] = []
    // Очередь для потокобезопасного доступа к массиву, а то налетят пидарасы-гонки данных
    let очередьДляРезультатов = DispatchQueue(label: "com.example.результаты", attributes: .concurrent)

    let урлы = [URL(string: "https://api.example.com/пользователи")!,
                URL(string: "https://api.example.com/посты")!,
                URL(string: "https://api.example.com/комменты")!]

    for url in урлы {
        group.enter() // "Му!"

        URLSession.shared.dataTask(with: url) { data, response, error in
            defer { group.leave() } // "Му!" в любом случае, даже если ошибка

            if let data = data {
                очередьДляРезультатов.async(flags: .barrier) { // Барьер, бля, чтобы не лезли
                    результаты.append(data)
                }
            }
        }.resume()
    }

    group.notify(queue: .main) {
        completion(результаты) // Всё загрузилось, можно отдавать
    }
}

2. Обработка файлов с ограничением по потокам и таймаутом, ёпта:

func обработатьФайлы(_ fileURLs: [URL], таймаут: TimeInterval = 30) {
    let group = DispatchGroup()
    let семафор = DispatchSemaphore(value: 3) // Не больше трёх файлов одновременно, а то комп взвоет

    for fileURL in fileURLs {
        group.enter() // "Му!"

        семафор.wait() // Ждём, если уже три в работе

        DispatchQueue.global().async {
            defer {
                семафор.signal() // Освобождаем слот
                group.leave()    // "Му!"
            }

            do {
                let data = try Data(contentsOf: fileURL)
                // Что-то делаем с файлом
                обработатьФайл(data)
            } catch {
                print("Файл (fileURL) оказался говном: (error)")
            }
        }
    }

    // Ждём, но не вечно, блядь
    let результатОжидания = group.wait(timeout: .now() + таймаут)

    switch результатОжидания {
    case .success:
        print("Все файлы обработаны, молодцы")
    case .timedOut:
        print("Таймаут, ёпта! Какие-то файлы ещё в процессе, но нам уже похуй")
        // Тут можно попробовать отменить оставшиеся операции
    }
}

3. Комбинация с OperationQueue, чтоб им всем пусто было:

func качнутьКартинки(_ imageURLs: [URL]) {
    let group = DispatchGroup()
    let operationQueue = OperationQueue()
    operationQueue.maxConcurrentOperationCount = 4 // Не больше четырёх параллельно

    var обработанныеКартинки: [UIImage] = []

    for url in imageURLs {
        group.enter() // "Му!"

        let operation = BlockOperation {
            defer { group.leave() } // "Му!" в любом исходе

            do {
                let data = try Data(contentsOf: url)
                if let image = UIImage(data: data) {
                    DispatchQueue.main.async {
                        обработанныеКартинки.append(image) // На главный поток для UI
                    }
                }
            } catch {
                print("Не удалось скачать картинку с (url), пидарас какой-то")
            }
        }

        operationQueue.addOperation(operation)
    }

    group.notify(queue: .main) {
        print("Скачано картинок: (обработанныеКартинки.count)")
        self.показатьКартинки(обработанныеКартинки)
    }
}

4. Вложенные группы, ёбаный в рот! Это когда Герасим считает "Му-му", а внутри каждого "Му" ещё свои "Му-му-му":

func сложныйСценарий() {
    let внешняяГруппа = DispatchGroup()
    let внутренняяГруппа = DispatchGroup()

    // Этап 1: Подготовка данных
    внешняяГруппа.enter()
    подготовитьДанные { data in
        defer { внешняяГруппа.leave() }

        // Этап 2: Параллельная обработка кусков
        for chunk in data.chunks {
            внутренняяГруппа.enter()

            обработатьКусок(chunk) { result in
                // Что-то делаем с результатом
                внутренняяГруппа.leave()
            }
        }

        // Ждём завершения всех кусков
        внутренняяГруппа.notify(queue: .global()) {
            print("Все куски обработаны, можно выдыхать")
        }
    }

    внешняяГруппа.notify(queue: .main) {
        print("Весь сложный сценарий выполнен, охуенно!")
    }
}

Важные моменты, блядь, чтобы не обосраться:

1. Всегда defer { group.leave() } — это как страховка, чтобы "Му!" сказалось даже если в середине операции пиздец.
2. Баланс enter() и leave() — если "Му!" сказал, а "Му!" не ответил, группа будет ждать вечно, как дурак.
3. Не блокируй главный поток wait()-ом — используй notify, а то UI замрёт, и пользователь пошлёт тебя нахуй.
4. Таймауты, сука! — group.wait(timeout:) чтобы не ждать до второго пришествия.
5. Комбинируй с семафорами — если нужно ограничить одновременное выполнение, как в примере с файлами.

Типичные косяки, ёпта:

// КОСЯК: enter без leave
let group = DispatchGroup()
group.enter()
DispatchQueue.global().async {
    // Забыли group.leave() — вечный дедлок, Герасим будет ждать своего "Му!" до скончания веков
}
group.wait() // Тут зависнем нахуй

// КОСЯК: leave без enter
group.leave() // Краш: over-released, счётчик ушёл в минус

// ПРАВИЛЬНО: defer, блядь!
func безопаснаяРабота(group: DispatchGroup) {
    group.enter()

    defer { group.leave() } // Сработает всегда, даже если ниже всё полетит к чертям

    let результат = try? рискованнаяОперация()
    // Что-то делаем...
}

Чем ещё можно заменить, если DispatchGroup надоел:

• OperationQueue с зависимостями — для сложных цепочек, где одна операция ждёт другую.
• Async/Await (Swift 5.5+) — современно, красиво, но не везде доступно.
• PromiseKit и аналоги — через промисы/фьючерсы.
• Combine — если ты любишь реактивщину и боль, блядь.

Когда DispatchGroup — твой выбор:

• Нужно просто дождаться кучки асинхронных задач.
• Мигрируешь старый код на GCD.
• Не хочешь тянуть лишние зависимости.
• Когда async/await ещё нельзя использовать, потому что проект на старом свифте, ёпта.

В общем, DispatchGroup — это как тот самый Герасим: простой, немой, но охуенно эффективный, когда нужно посчитать все "Му-му" и сказать, что всё готово. Главное — не забывать отвечать ему "Му!" на каждый его "Му!", а то он обидится и зависнет навеки.