Как реализуешь 10 запросов в сеть через GCD?

Реализация 10 сетевых запросов через GCD

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

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

1. Concurrent очередь с группой dispatch group

Наиболее популярный способ для выполнения нескольких асинхронных операций с возможностью отслеживания их завершения.

import Foundation

func perform10NetworkRequests() {
    let concurrentQueue = DispatchQueue(label: "com.example.network.concurrent", attributes: .concurrent)
    let group = DispatchGroup()
    
    for i in 1...10 {
        group.enter() // Входим в группу перед каждым запросом
        
        concurrentQueue.async {
            // Имитация сетевого запроса
            print("Запрос \(i) начат")
            Thread.sleep(forTimeInterval: Double.random(in: 0.5...2.0))
            print("Запрос \(i) завершен")
            
            group.leave() // Покидаем группу после завершения
        }
    }
    
    // Ожидаем завершения всех запросов
    group.notify(queue: .main) {
        print("Все 10 запросов завершены!")
        // Обновляем UI или обрабатываем результаты
    }
}

2. OperationQueue с ограничением параллельных операций

Более гибкий подход, позволяющий контролировать максимальное количество одновременно выполняемых запросов.

func perform10NetworkRequestsWithOperationQueue() {
    let operationQueue = OperationQueue()
    operationQueue.maxConcurrentOperationCount = 3 // Ограничиваем параллельные запросы
    
    var results: [Int: String] = [:]
    let lock = NSLock() // Для потокобезопасного доступа к результатам
    
    for i in 1...10 {
        let operation = BlockOperation {
            // Имитация сетевого запроса
            let result = "Результат запроса \(i)"
            Thread.sleep(forTimeInterval: Double.random(in: 0.5...2.0))
            
            lock.lock()
            results[i] = result
            lock.unlock()
        }
        
        operationQueue.addOperation(operation)
    }
    
    operationQueue.addBarrierBlock {
        DispatchQueue.main.async {
            print("Все операции завершены. Результаты: \(results)")
        }
    }
}

3. Async/await с параллельным выполнением (Swift 5.5+)

Современный подход с использованием структурированного параллелизма.

import Foundation

func perform10NetworkRequestsAsync() async throws -> [Int: String] {
    async let request1 = performSingleRequest(id: 1)
    async let request2 = performSingleRequest(id: 2)
    async let request3 = performSingleRequest(id: 3)
    async let request4 = performSingleRequest(id: 4)
    async let request5 = performSingleRequest(id: 5)
    async let request6 = performSingleRequest(id: 6)
    async let request7 = performSingleRequest(id: 7)
    async let request8 = performSingleRequest(id: 8)
    async let request9 = performSingleRequest(id: 9)
    async let request10 = performSingleRequest(id: 10)
    
    // Все запросы выполняются параллельно
    return try await [
        1: request1, 2: request2, 3: request3, 4: request4, 5: request5,
        6: request6, 7: request7, 8: request8, 9: request9, 10: request10
    ]
}

func performSingleRequest(id: Int) async throws -> String {
    // Имитация асинхронного сетевого запроса
    try await Task.sleep(nanoseconds: UInt64.random(in: 500_000_000...2_000_000_000))
    return "Результат \(id)"
}

Критические аспекты реализации

Управление ресурсами

• Семафоры DispatchSemaphore для точного контроля количества одновременных запросов
• Барьеры (barrier) для синхронизации доступа к общим ресурсам
• Приоритеты качества обслуживания (QoS) для классификации запросов

Обработка ошибок

func performRequestsWithErrorHandling() {
    let group = DispatchGroup()
    let queue = DispatchQueue.global(qos: .userInitiated)
    var errors: [Error] = []
    let errorLock = NSLock()
    
    for i in 1...10 {
        group.enter()
        
        queue.async {
            do {
                let result = try performNetworkRequest(id: i)
                print("Успех: \(result)")
            } catch {
                errorLock.lock()
                errors.append(error)
                errorLock.unlock()
            }
            group.leave()
        }
    }
    
    group.notify(queue: .main) {
        if errors.isEmpty {
            print("Все запросы успешны")
        } else {
            print("Ошибки: \(errors.count)")
        }
    }
}

Оптимизация производительности

• Использование concurrent очереди для максимального параллелизма
• Настройка maxConcurrentOperationCount в OperationQueue для предотвращения перегрузки сети
• Кэширование результатов с помощью NSCache или URLCache
• Приоритизация запросов через QoS

Рекомендации по выбору подхода

1. DispatchGroup — оптимален для простых сценариев с фиксированным числом запросов
2. OperationQueue — предпочтителен при необходимости отмены операций, зависимостей между запросами
3. Async/await — современное решение для Swift 5.5+, улучшает читаемость и поддерживает структурированную обработку ошибок
4. Combine — альтернатива для реактивного программирования

Важные замечания

• Все сетевые запросы должны выполняться в фоновых очередях
• Обновление UI всегда должно происходить в main очереди
• Необходимо учитывать ограничения сети и заряд батареи
• Рекомендуется реализовать retry механизм для неудачных запросов
• Для реальных сетевых запросов используйте URLSession вместо имитации

Выбор конкретной реализации зависит от требований проекта, необходимости обработки ошибок, управления зависимостями между запросами и версии Swift.